diff options
Diffstat (limited to 'js/src')
104 files changed, 25737 insertions, 0 deletions
diff --git a/js/src/Glacier2/.gitignore b/js/src/Glacier2/.gitignore new file mode 100644 index 00000000000..bf696523d2d --- /dev/null +++ b/js/src/Glacier2/.gitignore @@ -0,0 +1,7 @@ +PermissionsVerifierF.js +PermissionsVerifier.js +Router.js +RouterF.js +Session.js +SSLInfo.js +Metrics.js diff --git a/js/src/Glacier2/Glacier2.js b/js/src/Glacier2/Glacier2.js new file mode 100644 index 00000000000..a91f42e425a --- /dev/null +++ b/js/src/Glacier2/Glacier2.js @@ -0,0 +1,15 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(){ + require("Glacier2/PermissionsVerifier"); + require("Glacier2/Router"); + require("Glacier2/Session"); + require("Glacier2/SSLInfo"); +}()); diff --git a/js/src/Glacier2/Makefile b/js/src/Glacier2/Makefile new file mode 100644 index 00000000000..d61956f5b3a --- /dev/null +++ b/js/src/Glacier2/Makefile @@ -0,0 +1,40 @@ +# ********************************************************************** +# +# Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +# +# This copy of Ice is licensed to you under the terms described in the +# ICE_LICENSE file included in this distribution. +# +# ********************************************************************** + +top_srcdir = ../.. + +LIBNAME = Glacier2 + +TARGETS = $(call mklibtargets,$(LIBNAME)) + +SLICES = $(SDIR)/PermissionsVerifierF.ice \ + $(SDIR)/PermissionsVerifier.ice \ + $(SDIR)/Router.ice \ + $(SDIR)/RouterF.ice \ + $(SDIR)/Session.ice \ + $(SDIR)/SSLInfo.ice \ + $(SDIR)/Metrics.ice + +SDIR = $(slicedir)/Glacier2 + +GEN_SRCS = $(patsubst $(SDIR)/%.ice, %.js, $(SLICES)) + +SRCS := $(GEN_SRCS) +INSTALL_SRCS := Glacier2.js $(GEN_SRCS) + +include $(top_srcdir)/config/Make.rules.js + +SLICE2JSFLAGS := $(SLICE2JSFLAGS) --ice -I$(slicedir) + +lint:: $(INSTALL_SRCS) + jshint $(LINTFLAGS) $(INSTALL_SRCS) + +install:: all + $(call installlib,$(DESTDIR)$(install_libdir),$(libdir),$(LIBNAME)) + $(call installmodule,$(DESTDIR)$(install_moduledir),$(INSTALL_SRCS),$(LIBNAME)) diff --git a/js/src/Glacier2/Makefile.mak b/js/src/Glacier2/Makefile.mak new file mode 100644 index 00000000000..482e18412ff --- /dev/null +++ b/js/src/Glacier2/Makefile.mak @@ -0,0 +1,39 @@ +# ********************************************************************** +# +# Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +# +# This copy of Ice is licensed to you under the terms described in the +# ICE_LICENSE file included in this distribution. +# +# ********************************************************************** + +top_srcdir = ..\.. + +LIBNAME = Glacier2 + +GEN_SRCS = PermissionsVerifierF.js \ + PermissionsVerifier.js \ + Router.js \ + RouterF.js \ + Session.js \ + SSLInfo.js \ + Metrics.js + +SDIR = $(slicedir)\Glacier2 + +SRCS = $(GEN_SRCS) +INSTALL_SRCS = Glacier2.js $(GEN_SRCS) + +!include $(top_srcdir)\config\Make.rules.mak.js + +SLICE2JSFLAGS = $(SLICE2JSFLAGS) --ice -I"$(slicedir)" + +MODULEDIR = $(install_moduledir)\$(LIBNAME) + +install:: all + @if not exist $(MODULEDIR) \ + @echo "Creating $(MODULEDIR)" && \ + mkdir "$(MODULEDIR)" + @for %i in ( $(INSTALL_SRCS) ) do \ + copy %i "$(MODULEDIR)" + copy package.json "$(MODULEDIR)" diff --git a/js/src/Glacier2/package.json b/js/src/Glacier2/package.json new file mode 100644 index 00000000000..f4d3062e38d --- /dev/null +++ b/js/src/Glacier2/package.json @@ -0,0 +1,5 @@ +{ + "name": "Glacier2", + "version": "0.1.0", + "main": "Glacier2.js" +} diff --git a/js/src/Ice/.gitignore b/js/src/Ice/.gitignore new file mode 100644 index 00000000000..77776474437 --- /dev/null +++ b/js/src/Ice/.gitignore @@ -0,0 +1,20 @@ +# Ignore generated files +BuiltinSequences.js +Connection.js +Current.js +Endpoint.js +EndpointTypes.js +Identity.js +LocalException.js +Locator.js +Metrics.js +Process.js +PropertiesAdmin.js +Router.js +ServantLocator.js +SliceChecksumDict.js +Version.js +ConnectionF.js +EndpointF.js +ObjectAdapterF.js +ProcessF.js diff --git a/js/src/Ice/Address.js b/js/src/Ice/Address.js new file mode 100644 index 00000000000..cfeeb2149c1 --- /dev/null +++ b/js/src/Ice/Address.js @@ -0,0 +1,22 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + var Ice = global.Ice || {}; + + var Address = function(host, port) + { + this.host = host; + this.port = port; + }; + + Ice.Address = Address; + + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ArrayUtil.js b/js/src/Ice/ArrayUtil.js new file mode 100644 index 00000000000..6389845d69b --- /dev/null +++ b/js/src/Ice/ArrayUtil.js @@ -0,0 +1,130 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + var Ice = global.Ice || {}; + var Slice = global.Slice || {}; + var ArrayUtil = {}; + + ArrayUtil.clone = function(arr) + { + if(arr === undefined) + { + return arr; + } + else if(arr === null) + { + return []; + } + else + { + return arr.slice(); + } + }; + + ArrayUtil.equals = function(v1, v2, equalFn) + { + var i, length; + + if(v1.length != v2.length) + { + return false; + } + + if(equalFn !== undefined && equalFn !== null) + { + for(i = 0, length = v1.length; i < length; ++i) + { + if(!equalFn.call(equalFn, v1[i], v2[i])) + { + return false; + } + } + } + else + { + for(i = 0, length = v1.length; i < length; ++i) + { + if(v1[i] != v2[i]) + { + return false; + } + } + } + + return true; + }; + + ArrayUtil.shuffle = function(arr) + { + for(var i = arr.length; i > 1; --i) + { + var e = arr[i - 1]; + var rand = Math.floor(Math.random() * i); + arr[i - 1] = arr[rand]; + arr[rand] = e; + } + }; + + ArrayUtil.indexOf = function(arr, elem, equalFn) + { + if(equalFn !== undefined && equalFn !== null) + { + for(var i = 0; i < arr.length; ++i) + { + if(equalFn.call(equalFn, arr[i], elem)) + { + return i; + } + } + } + else + { + return arr.indexOf(elem); + } + + return -1; + }; + + ArrayUtil.filter = function(arr, includeFn, obj) + { + obj = obj === undefined ? includeFn : obj; + var result = []; + for(var i = 0; i < arr.length; ++i) + { + if(includeFn.call(obj, arr[i], i, arr)) + { + result.push(arr[i]); + } + } + return result; + }; + + Slice.defineSequence = function(module, name, valueHelper, fixed, elementType) + { + var helper = null; + Object.defineProperty(module, name, + { + get: function() + { + if(helper === null) + { + /*jshint -W061 */ + helper = Ice.StreamHelpers.generateSeqHelper(eval(valueHelper), fixed, eval(elementType)); + /*jshint +W061 */ + } + return helper; + } + }); + }; + + Ice.ArrayUtil = ArrayUtil; + global.Slice = Slice; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/AsyncResult.js b/js/src/Ice/AsyncResult.js new file mode 100644 index 00000000000..1f2d5f8c6b2 --- /dev/null +++ b/js/src/Ice/AsyncResult.js @@ -0,0 +1,120 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/AsyncResultBase"); + require("Ice/Debug"); + require("Ice/Promise"); + require("Ice/Protocol"); + require("Ice/Exception"); + require("Ice/BasicStream"); + + var Ice = global.Ice || {}; + + var AsyncResultBase = Ice.AsyncResultBase; + var Debug = Ice.Debug; + var Promise = Ice.Promise; + var Protocol = Ice.Protocol; + var UserException = Ice.UserException; + var BasicStream = Ice.BasicStream; + + var AsyncResult = Ice.Class(AsyncResultBase, { + __init__: function(communicator, op, connection, proxy, adapter, completedFn, sentFn) + { + // + // AsyncResult can be constructed by a sub-type's prototype, in which case the + // arguments are undefined. + // + AsyncResultBase.call(this, communicator, op, connection, proxy, adapter); + if(communicator !== undefined) + { + this._completed = completedFn; + this._sent = sentFn; + this._is = null; + this._os = communicator !== null ? + new BasicStream(this._instance, Protocol.currentProtocolEncoding, false) : null; + this._state = 0; + this._exception = null; + } + }, + __os: function() + { + return this._os; + }, + __is: function() + { + return this._is; + }, + __startReadParams: function() + { + this._is.startReadEncaps(); + return this._is; + }, + __endReadParams: function() + { + this._is.endReadEncaps(); + }, + __readEmptyParams: function() + { + this._is.skipEmptyEncaps(null); + }, + __readParamEncaps: function() + { + return this._is.readEncaps(null); + }, + __throwUserException: function() + { + Debug.assert((this._state & AsyncResult.Done) !== 0); + if((this._state & AsyncResult.OK) === 0) + { + try + { + this._is.startReadEncaps(); + this._is.throwException(); + } + catch(ex) + { + if(ex instanceof UserException) + { + this._is.endReadEncaps(); + } + throw ex; + } + } + }, + __exception: function(ex) + { + this._state |= AsyncResult.Done; + this._exception = ex; + this._os.resize(0); + this.fail(ex, this); + }, + __response: function() + { + // + // Note: no need to change the state here, specializations are responsible for + // changing the state. + // + + if(this.proxy !== null && this.proxy.ice_isTwoway()) + { + Debug.assert(this._completed !== null); + this._completed(this); + } + } + }); + + AsyncResult.OK = 0x1; + AsyncResult.Done = 0x2; + AsyncResult.Sent = 0x4; + + Ice.AsyncResult = AsyncResult; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/AsyncResultBase.js b/js/src/Ice/AsyncResultBase.js new file mode 100644 index 00000000000..348c715082e --- /dev/null +++ b/js/src/Ice/AsyncResultBase.js @@ -0,0 +1,70 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Debug"); + require("Ice/Promise"); + require("Ice/Exception"); + + var Ice = global.Ice || {}; + + var Promise = Ice.Promise; + + var AsyncResultBase = Ice.Class(Promise, { + __init__: function(communicator, op, connection, proxy, adapter) + { + // + // AsyncResultBase can be constructed by a sub-type's prototype, in which case the + // arguments are undefined. + // + Promise.call(this); + if(communicator !== undefined) + { + this._communicator = communicator; + this._instance = communicator !== null ? communicator.instance : null; + this._operation = op; + this._connection = connection; + this._proxy = proxy; + this._adapter = adapter; + } + }, + __exception: function(ex) + { + this.fail(ex); + } + }); + + var prototype = AsyncResultBase.prototype; + var defineProperty = Object.defineProperty; + + defineProperty(prototype, "communicator", { + get: function() { return this._communicator; } + }); + + defineProperty(prototype, "connection", { + get: function() { return this._connection; } + }); + + defineProperty(prototype, "proxy", { + get: function() { return this._proxy; } + }); + + defineProperty(prototype, "adapter", { + get: function() { return this._adapter; } + }); + + defineProperty(prototype, "operation", { + get: function() { return this._operation; } + }); + + Ice.AsyncResultBase = AsyncResultBase; + + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/AsyncStatus.js b/js/src/Ice/AsyncStatus.js new file mode 100644 index 00000000000..e8d3142bcf9 --- /dev/null +++ b/js/src/Ice/AsyncStatus.js @@ -0,0 +1,15 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + var Ice = global.Ice || {}; + var AsyncStatus = {Queued: 0, Sent: 1}; + Ice.AsyncStatus = AsyncStatus; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Base64.js b/js/src/Ice/Base64.js new file mode 100644 index 00000000000..f1f9ec47964 --- /dev/null +++ b/js/src/Ice/Base64.js @@ -0,0 +1,276 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Buffer"); + + var Ice = global.Ice || {}; + + var Buffer = Ice.Buffer; + + var Base64 = {}; + + var _codeA = "A".charCodeAt(0); + var _codea = "a".charCodeAt(0); + var _code0 = "0".charCodeAt(0); + + Base64.encode = function(buf) // Expects native Buffer + { + if(buf === null || buf.length === 0) + { + return ""; + } + + var base64Bytes = (((buf.length * 4) / 3) + 1); + var newlineBytes = (((base64Bytes * 2) / 76) + 1); + var totalBytes = base64Bytes + newlineBytes; + + var v = []; + + var by1; + var by2; + var by3; + var by4; + var by5; + var by6; + var by7; + + for(var i = 0; i < buf.length; i += 3) + { + by1 = buf[i] & 0xff; + by2 = 0; + by3 = 0; + + if((i + 1) < buf.length) + { + by2 = buf[i + 1] & 0xff; + } + + if((i + 2) < buf.length) + { + by3 = buf[i + 2] & 0xff; + } + + by4 = (by1 >> 2) & 0xff; + by5 = (((by1 & 0x3) << 4) | (by2 >> 4)) & 0xff; + by6 = (((by2 & 0xf) << 2) | (by3 >> 6)) & 0xff; + by7 = by3 & 0x3f; + + v.push(encodeChar(by4)); + v.push(encodeChar(by5)); + + if((i + 1) < buf.length) + { + v.push(encodeChar(by6)); + } + else + { + v.push("="); + } + + if((i + 2) < buf.length) + { + v.push(encodeChar(by7)); + } + else + { + v.push("="); + } + } + + var retval = v.join(""); + var outString = []; + var iter = 0; + + while((retval.length - iter) > 76) + { + outString.push(retval.substring(iter, iter + 76)); + outString.push("\r\n"); + iter += 76; + } + + outString.push(retval.substring(iter)); + + return outString.join(""); + }; + + Base64.decode = function(str) // Returns native Buffer + { + var newStr = []; + + for(var j = 0; j < str.length; j++) + { + var c = str.charAt(j); + if(Base64.isBase64(c)) + { + newStr.push(c); + } + } + + if(newStr.length === 0) + { + return null; + } + + // Note: This is how we were previously computing the size of the return + // sequence. The method below is more efficient (and correct). + // size_t lines = str.size() / 78; + // size_t totalBytes = (lines * 76) + (((str.size() - (lines * 78)) * 3) / 4); + + // Figure out how long the final sequence is going to be. + var totalBytes = (newStr.length * 3 / 4) + 1; + + var retval = new Buffer(); + retval.resize(totalBytes); + + var by1; + var by2; + var by3; + var by4; + + var c1; + var c2; + var c3; + var c4; + + var off = 0; + + for(var i = 0; i < newStr.length; i += 4) + { + c1 = "A"; + c2 = "A"; + c3 = "A"; + c4 = "A"; + + c1 = newStr[i]; + + if((i + 1) < newStr.length) + { + c2 = newStr[i + 1]; + } + + if((i + 2) < newStr.length) + { + c3 = newStr[i + 2]; + } + + if((i + 3) < newStr.length) + { + c4 = newStr[i + 3]; + } + + by1 = decodeChar(c1) & 0xff; + by2 = decodeChar(c2) & 0xff; + by3 = decodeChar(c3) & 0xff; + by4 = decodeChar(c4) & 0xff; + + retval.put((by1 << 2) | (by2 >> 4)); + + if(c3 != "=") + { + retval.put(((by2 & 0xf) << 4) | (by3 >> 2)); + } + + if(c4 != "=") + { + retval.put(((by3 & 0x3) << 6) | by4); + } + } + + return retval.remaining > 0 ? retval.getArrayAt(0, retval.position) : retval.getArrayAt(0); + }; + + Base64.isBase64 = function(c) + { + if(c >= 'A' && c <= 'Z') + { + return true; + } + + if(c >= 'a' && c <= 'z') + { + return true; + } + + if(c >= '0' && c <= '9') + { + return true; + } + + if(c == '+') + { + return true; + } + + if(c == '/') + { + return true; + } + + if(c == '=') + { + return true; + } + + return false; + }; + + function encodeChar(uc) + { + if(uc < 26) + { + return String.fromCharCode(_codeA + uc); + } + + if(uc < 52) + { + return String.fromCharCode(_codea + (uc - 26)); + } + + if(uc < 62) + { + return String.fromCharCode(_code0 + (uc - 52)); + } + + if(uc == 62) + { + return "+"; + } + + return "/"; + } + + function decodeChar(c) + { + if(c >= 'A' && c <= 'Z') + { + return c.charCodeAt(0) - _codeA; + } + + if(c >= 'a' && c <= 'z') + { + return c.charCodeAt(0) - _codea + 26; + } + + if(c >= '0' && c <= '9') + { + return c.charCodeAt(0) - _code0 + 52; + } + + if(c == '+') + { + return 62; + } + + return 63; + } + + Ice.Base64 = Base64; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/BasicStream.js b/js/src/Ice/BasicStream.js new file mode 100644 index 00000000000..db423be4c91 --- /dev/null +++ b/js/src/Ice/BasicStream.js @@ -0,0 +1,2961 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Debug"); + require("Ice/ExUtil"); + require("Ice/FormatType"); + require("Ice/HashMap"); + require("Ice/Object"); + require("Ice/OptionalFormat"); + require("Ice/Protocol"); + require("Ice/TraceUtil"); + require("Ice/Buffer"); + require("Ice/Exception"); + require("Ice/LocalException"); + require("Ice/Version"); + require("Ice/CompactIdRegistry"); + require("Ice/ArrayUtil"); + require("Ice/UnknownSlicedObject"); + + var Ice = global.Ice || {}; + + var Debug = Ice.Debug; + var ExUtil = Ice.ExUtil; + var FormatType = Ice.FormatType; + var HashMap = Ice.HashMap; + var IceObject = Ice.Object; + var OptionalFormat = Ice.OptionalFormat; + var Protocol = Ice.Protocol; + var TraceUtil = Ice.TraceUtil; + var ArrayUtil = Ice.ArrayUtil; + var SlicedData = Ice.SlicedData; + + var SliceType = {}; + SliceType.NoSlice = 0; + SliceType.ObjectSlice = 1; + SliceType.ExceptionSlice = 2; + + var OPTIONAL_END_MARKER = 0xFF; + var FLAG_HAS_TYPE_ID_STRING = (1<<0); + var FLAG_HAS_TYPE_ID_INDEX = (1<<1); + var FLAG_HAS_TYPE_ID_COMPACT = (1<<1 | 1<<0); + var FLAG_HAS_OPTIONAL_MEMBERS = (1<<2); + var FLAG_HAS_INDIRECTION_TABLE = (1<<3); + var FLAG_HAS_SLICE_SIZE = (1<<4); + var FLAG_IS_LAST_SLICE = (1<<5); + + var IndirectPatchEntry = function(index, patcher) + { + this.index = index; + this.patcher = patcher; + }; + + var Class = Ice.Class; + + var EncapsDecoder = Class({ + __init__: function(stream, encaps, sliceObjects, f) + { + this._stream = stream; + this._encaps = encaps; + this._sliceObjects = sliceObjects; + this._servantFactoryManager = f; + this._patchMap = null; // Lazy initialized, HashMap<int, Patcher[] >() + this._unmarshaledMap = new HashMap(); // HashMap<int, Ice.Object>() + this._typeIdMap = null; // Lazy initialized, HashMap<int, String> + this._typeIdIndex = 0; + this._objectList = null; // Lazy initialized. Ice.Object[] + }, + readOpt: function() + { + return false; + }, + readPendingObjects: function() + { + }, + readTypeId: function(isIndex) + { + var typeId, index; + if(this._typeIdMap === null) // Lazy initialization + { + this._typeIdMap = new HashMap(); // Map<int, String>(); + } + + if(isIndex) + { + index = this._stream.readSize(); + typeId = this._typeIdMap.get(index); + if(typeId === undefined) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + } + else + { + typeId = this._stream.readString(); + this._typeIdMap.set(++this._typeIdIndex, typeId); + } + return typeId; + }, + newInstance: function(typeId) + { + // + // Try to find a factory registered for the specific type. + // + var userFactory = this._servantFactoryManager.find(typeId); + var v = null; + + if(userFactory !== undefined) + { + v = userFactory.create(typeId); + } + + // + // If that fails, invoke the default factory if one has been + // registered. + // + if(v === null || v === undefined) + { + userFactory = this._servantFactoryManager.find(""); + if(userFactory !== undefined) + { + v = userFactory.create(typeId); + } + } + + // + // Last chance: try to instantiate the class dynamically. + // + if(v === null || v === undefined) + { + v = this._stream.createObject(typeId); + } + + return v; + }, + addPatchEntry: function(index, patcher) + { + Debug.assert(index > 0); + // + // Check if already un-marshalled the object. If that's the case, + // just patch the object smart pointer and we're done. + // + var obj = this._unmarshaledMap.get(index); + if(obj !== undefined && obj !== null) + { + patcher.call(null, obj); + return; + } + + if(this._patchMap === null) // Lazy initialization + { + this._patchMap = new HashMap(); // HashMap<Integer, Patcher[] >(); + } + + // + // Add patch entry if the object isn't un-marshalled yet, + // the smart pointer will be patched when the instance is + // un-marshalled. + // + var l = this._patchMap.get(index); + if(l === undefined) + { + // + // We have no outstanding instances to be patched for this + // index, so make a new entry in the patch map. + // + l = []; // Patcher[]; + this._patchMap.set(index, l); + } + + // + // Append a patch entry for this instance. + // + l.push(patcher); + }, + unmarshal: function(index, v) + { + var i, length, l; + // + // Add the object to the map of un-marshalled objects, this must + // be done before reading the objects (for circular references). + // + this._unmarshaledMap.set(index, v); + + // + // Read the object. + // + v.__read(this._stream); + if(this._patchMap !== null) + { + // + // Patch all instances now that the object is un-marshalled. + // + l = this._patchMap.get(index); + if(l !== undefined) + { + Debug.assert(l.length > 0); + // + // Patch all pointers that refer to the instance. + // + for(i = 0, length = l.length; i < length; ++i) + { + l[i](v); + } + // + // Clear out the patch map for that index -- there is nothing left + // to patch for that index for the time being. + // + this._patchMap.delete(index); + } + } + + if((this._patchMap === null || this._patchMap.size === 0) && this._objectList === null) + { + try + { + v.ice_postUnmarshal(); + } + catch(ex) + { + this._stream.instance.initializationData().logger.warning("exception raised by ice_postUnmarshal:\n" + + ExUtil.toString(ex)); + } + } + else + { + if(this._objectList === null) // Lazy initialization + { + this._objectList = []; // Ice.Object[] + } + this._objectList.push(v); + + if(this._patchMap === null || this._patchMap.size === 0) + { + // + // Iterate over the object list and invoke ice_postUnmarshal on + // each object. We must do this after all objects have been + // unmarshaled in order to ensure that any object data members + // have been properly patched. + // + for(i = 0, length = this._objectList.length; i < length; i++) + { + try + { + this._objectList[i].ice_postUnmarshal(); + } + catch(ex) + { + this._stream.instance.initializationData().logger.warning( + "exception raised by ice_postUnmarshal:\n" + ExUtil.toString(ex)); + } + } + this._objectList = []; + } + } + } + }); + + var EncapsDecoder10 = Class(EncapsDecoder, { + __init__: function(stream, encaps, sliceObjects, f) + { + EncapsDecoder.call(this, stream, encaps, sliceObjects, f); + this._sliceType = SliceType.NoSlice; + }, + readObject: function(patcher) + { + Debug.assert(patcher !== null); + + // + // Object references are encoded as a negative integer in 1.0. + // + var index = this._stream.readInt(); + if(index > 0) + { + throw new Ice.MarshalException("invalid object id"); + } + index = -index; + + if(index === 0) + { + patcher.call(null, null); + } + else + { + this.addPatchEntry(index, patcher); + } + }, + throwException: function() + { + Debug.assert(this._sliceType === SliceType.NoSlice); + + // + // User exception with the 1.0 encoding start with a boolean flag + // that indicates whether or not the exception has classes. + // + // This allows reading the pending objects even if some part of + // the exception was sliced. + // + var usesClasses = this._stream.readBool(); + this._sliceType = SliceType.ExceptionSlice; + this._skipFirstSlice = false; + + // + // Read the first slice header. + // + this.startSlice(); + var mostDerivedId = this._typeId; + while(true) + { + var userEx = this._stream.createUserException(this._typeId); + + // + // We found the exception. + // + if(userEx !== null) + { + userEx.__read(this._stream); + if(usesClasses) + { + this.readPendingObjects(); + } + throw userEx; + + // Never reached. + } + + // + // Slice off what we don't understand. + // + this.skipSlice(); + try + { + this.startSlice(); + } + catch(ex) + { + // + // An oversight in the 1.0 encoding means there is no marker to indicate + // the last slice of an exception. As a result, we just try to read the + // next type ID, which raises UnmarshalOutOfBoundsException when the + // input buffer underflows. + // + // Set the reason member to a more helpful message. + // + if(ex instanceof Ice.UnmarshalOutOfBoundsException) + { + ex.reason = "unknown exception type `" + mostDerivedId + "'"; + } + throw ex; + } + } + }, + startInstance: function(sliceType) + { + Debug.assert(this._sliceType === sliceType); + this._skipFirstSlice = true; + }, + endInstance: function(/*preserve*/) + { + var sz; + // + // Read the Ice::Object slice. + // + if(this._sliceType === SliceType.ObjectSlice) + { + this.startSlice(); + sz = this._stream.readSize(); // For compatibility with the old AFM. + if(sz !== 0) + { + throw new Ice.MarshalException("invalid Object slice"); + } + this.endSlice(); + } + + this._sliceType = SliceType.NoSlice; + return null; + }, + startSlice: function() + { + var isIndex; + // + // If first slice, don't read the header, it was already read in + // readInstance or throwException to find the factory. + // + if(this._skipFirstSlice) + { + this._skipFirstSlice = false; + return this._typeId; + } + + // + // For objects, first read the type ID boolean which indicates + // whether or not the type ID is encoded as a string or as an + // index. For exceptions, the type ID is always encoded as a + // string. + // + if(this._sliceType === SliceType.ObjectSlice) // For exceptions, the type ID is always encoded as a string + { + isIndex = this._stream.readBool(); + this._typeId = this.readTypeId(isIndex); + } + else + { + this._typeId = this._stream.readString(); + } + + this._sliceSize = this._stream.readInt(); + if(this._sliceSize < 4) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + + return this._typeId; + }, + endSlice: function() + { + }, + skipSlice: function() + { + if(this._stream.instance.traceLevels().slicing > 0) + { + var logger = this._stream.instance.initializationData().logger; + if(this._sliceType === SliceType.ObjectSlice) + { + TraceUtil.traceSlicing("object", this._typeId, this._stream.instance.traceLevels().slicingCat, logger); + } + else + { + TraceUtil.traceSlicing("exception", this._typeId, this._stream.instance.traceLevels().slicingCat, logger); + } + } + Debug.assert(this._sliceSize >= 4); + this._stream.skip(this._sliceSize - 4); + }, + readPendingObjects: function() + { + var k, num; + do + { + num = this._stream.readSize(); + for(k = num; k > 0; --k) + { + this.readInstance(); + } + } + while(num > 0); + + if(this._patchMap !== null && this._patchMap.size !== 0) + { + // + // If any entries remain in the patch map, the sender has sent an index for an object, but failed + // to supply the object. + // + throw new Ice.MarshalException("index for class received, but no instance"); + } + }, + readInstance: function() + { + var index = this._stream.readInt(), + mostDerivedId, + v = null; + + if(index <= 0) + { + throw new Ice.MarshalException("invalid object id"); + } + + this._sliceType = SliceType.ObjectSlice; + this._skipFirstSlice = false; + + // + // Read the first slice header. + // + this.startSlice(); + mostDerivedId = this._typeId; + while(true) + { + // + // For the 1.0 encoding, the type ID for the base Object class + // marks the last slice. + // + if(this._typeId == IceObject.ice_staticId()) + { + throw new Ice.NoObjectFactoryException("", mostDerivedId); + } + + v = this.newInstance(this._typeId); + + // + // We found a factory, we get out of this loop. + // + if(v) + { + break; + } + + // + // If object slicing is disabled, stop un-marshalling. + // + if(!this._sliceObjects) + { + throw new Ice.NoObjectFactoryException("object slicing is disabled", this._typeId); + } + + // + // Slice off what we don't understand. + // + this.skipSlice(); + this.startSlice(); // Read next Slice header for next iteration. + } + + // + // Un-marshal the object and add-it to the map of un-marshaled objects. + // + this.unmarshal(index, v); + } + }); + + var EncapsDecoder11 = Class(EncapsDecoder, { + __init__: function(stream, encaps, sliceObjects, f) + { + EncapsDecoder.call(this, stream, encaps, sliceObjects, f); + this._current = null; + this._objectIdIndex = 1; + }, + readObject: function(patcher) + { + Debug.assert(patcher !== undefined); + var index = this._stream.readSize(); + + if(index < 0) + { + throw new Ice.MarshalException("invalid object id"); + } + + if(index === 0) + { + if(patcher !== null) + { + patcher.call(null, null); + } + } + else if(this._current !== null && (this._current.sliceFlags & FLAG_HAS_INDIRECTION_TABLE) !== 0) + { + // + // When reading an object within a slice and there's an + // indirect object table, always read an indirect reference + // that points to an object from the indirect object table + // marshaled at the end of the Slice. + // + // Maintain a list of indirect references. Note that the + // indirect index starts at 1, so we decrement it by one to + // derive an index into the indirection table that we'll read + // at the end of the slice. + // + if(patcher !== null) + { + if(this._current.indirectPatchList === null) // Lazy initialization + { + this._current.indirectPatchList = []; // IndirectPatchEntry[] + } + var e = new IndirectPatchEntry(); + e.index = index - 1; + e.patcher = patcher; + this._current.indirectPatchList.push(e); + } + } + else + { + this.readInstance(index, patcher); + } + }, + throwException: function() + { + Debug.assert(this._current === null); + this.push(SliceType.ExceptionSlice); + + // + // Read the first slice header. + // + this.startSlice(); + var mostDerivedId = this._current.typeId; + while(true) + { + + var userEx = this._stream.createUserException(this._current.typeId); + + // + // We found the exception. + // + if(userEx !== null) + { + userEx.__read(this._stream); + throw userEx; + + // Never reached. + } + + // + // Slice off what we don't understand. + // + this.skipSlice(); + + if((this._current.sliceFlags & FLAG_IS_LAST_SLICE) !== 0) + { + if(mostDerivedId.indexOf("::") === 0) + { + throw new Ice.UnknownUserException(mostDerivedId.substr(2)); + } + throw new Ice.UnknownUserException(mostDerivedId); + } + + this.startSlice(); + } + }, + startInstance: function(sliceType) + { + Debug.assert(sliceType !== undefined); + Debug.assert(this._current.sliceType !== null && this._current.sliceType === sliceType); + this._current.skipFirstSlice = true; + }, + endInstance: function(preserve) + { + var slicedData = null; + if(preserve) + { + slicedData = this.readSlicedData(); + } + if(this._current.slices !== null) + { + this._current.slices.length = 0; // Clear the array. + this._current.indirectionTables.length = 0; // Clear the array. + } + this._current = this._current.previous; + return slicedData; + }, + startSlice: function() + { + // + // If first slice, don't read the header, it was already read in + // readInstance or throwException to find the factory. + // + if(this._current.skipFirstSlice) + { + this._current.skipFirstSlice = false; + return this._current.typeId; + } + + this._current.sliceFlags = this._stream.readByte(); + + // + // Read the type ID, for object slices the type ID is encoded as a + // string or as an index, for exceptions it's always encoded as a + // string. + // + if(this._current.sliceType === SliceType.ObjectSlice) + { + if((this._current.sliceFlags & FLAG_HAS_TYPE_ID_COMPACT) === FLAG_HAS_TYPE_ID_COMPACT) // Must be checked 1st! + { + this._current.typeId = ""; + this._current.compactId = this._stream.readSize(); + } + else if((this._current.sliceFlags & (FLAG_HAS_TYPE_ID_INDEX | FLAG_HAS_TYPE_ID_STRING)) !== 0) + { + this._current.typeId = this.readTypeId((this._current.sliceFlags & FLAG_HAS_TYPE_ID_INDEX) !== 0); + this._current.compactId = -1; + } + else + { + // Only the most derived slice encodes the type ID for the compact format. + this._current.typeId = ""; + this._current.compactId = -1; + } + } + else + { + this._current.typeId = this._stream.readString(); + this._current.compactId = -1; + } + + // + // Read the slice size if necessary. + // + if((this._current.sliceFlags & FLAG_HAS_SLICE_SIZE) !== 0) + { + this._current.sliceSize = this._stream.readInt(); + if(this._current.sliceSize < 4) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + } + else + { + this._current.sliceSize = 0; + } + return this._current.typeId; + }, + endSlice: function() + { + var e, + i, + indirectionTable = [], + length; + + if((this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) !== 0) + { + this._stream.skipOpts(); + } + + // + // Read the indirection table if one is present and transform the + // indirect patch list into patch entries with direct references. + // + if((this._current.sliceFlags & FLAG_HAS_INDIRECTION_TABLE) !== 0) + { + // + // The table is written as a sequence<size> to conserve space. + // + length = this._stream.readAndCheckSeqSize(1); + for(i = 0; i < length; ++i) + { + indirectionTable[i] = this.readInstance(this._stream.readSize(), null); + } + + // + // Sanity checks. If there are optional members, it's possible + // that not all object references were read if they are from + // unknown optional data members. + // + if(indirectionTable.length === 0) + { + throw new Ice.MarshalException("empty indirection table"); + } + if((this._current.indirectPatchList === null || this._current.indirectPatchList.length === 0) && + (this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) === 0) + { + throw new Ice.MarshalException("no references to indirection table"); + } + + // + // Convert indirect references into direct references. + // + if(this._current.indirectPatchList !== null) + { + for(i = 0, length = this._current.indirectPatchList.length; i < length; ++i) + { + e = this._current.indirectPatchList[i]; + Debug.assert(e.index >= 0); + if(e.index >= indirectionTable.length) + { + throw new Ice.MarshalException("indirection out of range"); + } + this.addPatchEntry(indirectionTable[e.index], e.patcher); + } + this._current.indirectPatchList.length = 0; + } + } + }, + skipSlice: function() + { + if(this._stream.instance.traceLevels().slicing > 0) + { + var logger = this._stream.instance.initializationData().logger; + var slicingCat = this._stream.instance.traceLevels().slicingCat; + if(this._current.sliceType === SliceType.ExceptionSlice) + { + TraceUtil.traceSlicing("exception", this._current.typeId, slicingCat, logger); + } + else + { + TraceUtil.traceSlicing("object", this._current.typeId, slicingCat, logger); + } + } + + var start = this._stream.pos; + + if((this._current.sliceFlags & FLAG_HAS_SLICE_SIZE) !== 0) + { + Debug.assert(this._current.sliceSize >= 4); + this._stream.skip(this._current.sliceSize - 4); + } + else + { + if(this._current.sliceType === SliceType.ObjectSlice) + { + throw new Ice.NoObjectFactoryException( + "compact format prevents slicing (the sender should use the sliced format instead)", + this._current.typeId); + } + + if(this._current.typeId.indexOf("::") === 0) + { + throw new Ice.UnknownUserException(this._current.typeId.substring(2)); + } + + throw new Ice.UnknownUserException(this._current.typeId); + } + + // + // Preserve this slice. + // + var info = new Ice.SliceInfo(); + info.typeId = this._current.typeId; + info.compactId = this._current.compactId; + info.hasOptionalMembers = (this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) !== 0; + info.isLastSlice = (this._current.sliceFlags & FLAG_IS_LAST_SLICE) !== 0; + + var b = this._stream._buf; + var end = b.position; + var dataEnd = end; + if(info.hasOptionalMembers) + { + // + // Don't include the optional member end marker. It will be re-written by + // endSlice when the sliced data is re-written. + // + --dataEnd; + } + + b.position = start; + info.bytes = b.getArray(dataEnd - start); + b.position = end; + + if(this._current.slices === null) // Lazy initialization + { + this._current.slices = []; // Ice.SliceInfo[] + this._current.indirectionTables = []; // int[] + } + + // + // Read the indirect object table. We read the instances or their + // IDs if the instance is a reference to an already un-marhsaled + // object. + // + // The SliceInfo object sequence is initialized only if + // readSlicedData is called. + // + + if((this._current.sliceFlags & FLAG_HAS_INDIRECTION_TABLE) !== 0) + { + var length = this._stream.readAndCheckSeqSize(1); + var indirectionTable = []; + for(var i = 0; i < length; ++i) + { + indirectionTable[i] = this.readInstance(this._stream.readSize(), null); + } + this._current.indirectionTables.push(indirectionTable); + } + else + { + this._current.indirectionTables.push(null); + } + this._current.slices.push(info); + }, + readOpt: function(readTag, expectedFormat) + { + if(this._current === null) + { + return this._stream.readOptImpl(readTag, expectedFormat); + } + + if((this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) !== 0) + { + return this._stream.readOptImpl(readTag, expectedFormat); + } + return false; + }, + readInstance: function(index, patcher) + { + Debug.assert(index > 0); + + var mostDerivedId, + v = null; + + if(index > 1) + { + if(patcher !== null) + { + this.addPatchEntry(index, patcher); + } + return index; + } + + this.push(SliceType.ObjectSlice); + + // + // Get the object ID before we start reading slices. If some + // slices are skiped, the indirect object table are still read and + // might read other objects. + // + index = ++this._objectIdIndex; + + // + // Read the first slice header. + // + this.startSlice(); + mostDerivedId = this._current.typeId; + while(true) + { + if(this._current.compactId >= 0) + { + // + // Translate a compact (numeric) type ID into a string type ID. + // + this._current.typeId = ""; + if(this._current.typeId.length === 0) + { + this._current.typeId = this._stream.getTypeId(this._current.compactId); + } + } + + if(this._current.typeId.length > 0) + { + v = this.newInstance(this._current.typeId); + // + // We found a factory, we get out of this loop. + // + if(v !== null && v !== undefined) + { + break; + } + } + + // + // If object slicing is disabled, stop un-marshalling. + // + if(!this._sliceObjects) + { + throw new Ice.NoObjectFactoryException("object slicing is disabled", this._current.typeId); + } + + // + // Slice off what we don't understand. + // + this.skipSlice(); + // + // If this is the last slice, keep the object as an opaque + // UnknownSlicedData object. + // + if((this._current.sliceFlags & FLAG_IS_LAST_SLICE) !== 0) + { + v = new Ice.UnknownSlicedObject(mostDerivedId); + break; + } + + this.startSlice(); // Read next Slice header for next iteration. + } + + // + // Un-marshal the object + // + this.unmarshal(index, v); + if(this._current === null && this._patchMap !== null && this._patchMap.size !== 0) + { + // + // If any entries remain in the patch map, the sender has sent an index for an object, but failed + // to supply the object. + // + throw new Ice.MarshalException("index for class received, but no instance"); + } + + if(patcher !== null) + { + patcher.call(null, v); + } + return index; + }, + readSlicedData: function() + { + var i, ii, table, info, j, jj; + + if(this._current.slices === null) // No preserved slices. + { + return null; + } + // + // The _indirectionTables member holds the indirection table for each slice + // in _slices. + // + Debug.assert(this._current.slices.length === this._current.indirectionTables.length); + for(i = 0, ii = this._current.slices.length; i < ii; ++i) + { + // + // We use the "objects" list in SliceInfo to hold references + // to the target objects. Note that the objects might not have + // been read yet in the case of a circular reference to an + // enclosing object. + // + table = this._current.indirectionTables[i]; + info = this._current.slices[i]; + info.objects = []; + jj = table ? table.length : 0; + for(j = 0; j < jj; ++j) + { + this.addPatchEntry(table[j], sequencePatcher(info.objects, j, IceObject)); + } + } + return new SlicedData(ArrayUtil.clone(this._current.slices)); + }, + push: function(sliceType) + { + if(this._current === null) + { + this._current = new EncapsDecoder11.InstanceData(null); + } + else + { + this._current = !this._current.next ? new EncapsDecoder11.InstanceData(this._current) : this._current.next; + } + this._current.sliceType = sliceType; + this._current.skipFirstSlice = false; + } + }); + + EncapsDecoder11.InstanceData = function(previous) + { + if(previous !== null) + { + previous.next = this; + } + this.previous = previous; + this.next = null; + + // Instance attributes + this.sliceType = null; + this.skipFirstSlice = false; + this.slices = null; // Preserved slices. Ice.SliceInfo[] + this.indirectionTables = null; // int[] + + // Slice attributes + this.sliceFlags = 0; + this.sliceSize = 0; + this.typeId = null; + this.compactId = 0; + this.indirectPatchList = null; // Lazy initialized, IndirectPatchEntry[] + }; + + var sequencePatcher = function(seq, index, T){ + return function(v) + { + if(v !== null && !(v instanceof T)) + { + ExUtil.throwUOE(T.ice_staticId(), v); + } + seq[index] = v; + }; + }; + + var EncapsEncoder = Class({ + __init__: function(stream, encaps) + { + this._stream = stream; + this._encaps = encaps; + this._marshaledMap = new HashMap(); // HashMap<Ice.Object, int>; + this._typeIdMap = null; // Lazy initialized. HashMap<String, int> + this._typeIdIndex = 0; + }, + writeOpt: function() + { + return false; + }, + writePendingObjects: function() + { + return undefined; + }, + registerTypeId: function(typeId) + { + if(this._typeIdMap === null) // Lazy initialization + { + this._typeIdMap = new HashMap(); // HashMap<String, int> + } + + var p = this._typeIdMap.get(typeId); + if(p !== undefined) + { + return p; + } + this._typeIdMap.set(typeId, ++this._typeIdIndex); + return -1; + } + }); + + var EncapsEncoder10 = Class(EncapsEncoder, { + __init__: function(stream, encaps) + { + EncapsEncoder.call(this, stream, encaps); + // Instance attributes + this._sliceType = SliceType.NoSlice; + this._writeSlice = 0; // Position of the slice data members + // Encapsulation attributes for object marshalling. + this._objectIdIndex = 0; + this._toBeMarshaledMap = new HashMap(); // HashMap<Ice.Object, Integer>(); + }, + writeObject: function(v) + { + Debug.assert(v !== undefined); + // + // Object references are encoded as a negative integer in 1.0. + // + if(v !== null) + { + this._stream.writeInt(-this.registerObject(v)); + } + else + { + this._stream.writeInt(0); + } + }, + writeUserException: function(v) + { + Debug.assert(v !== null && v !== undefined); + // + // User exception with the 1.0 encoding start with a boolean + // flag that indicates whether or not the exception uses + // classes. + // + // This allows reading the pending objects even if some part of + // the exception was sliced. + // + var usesClasses = v.__usesClasses(); + this._stream.writeBool(usesClasses); + v.__write(this._stream); + if(usesClasses) + { + this.writePendingObjects(); + } + }, + startInstance: function(sliceType) + { + this._sliceType = sliceType; + }, + endInstance: function() + { + if(this._sliceType === SliceType.ObjectSlice) + { + // + // Write the Object slice. + // + this.startSlice(IceObject.ice_staticId(), -1, true); + this._stream.writeSize(0); // For compatibility with the old AFM. + this.endSlice(); + } + this._sliceType = SliceType.NoSlice; + }, + startSlice: function(typeId) + { + // + // For object slices, encode a boolean to indicate how the type ID + // is encoded and the type ID either as a string or index. For + // exception slices, always encode the type ID as a string. + // + if(this._sliceType === SliceType.ObjectSlice) + { + var index = this.registerTypeId(typeId); + if(index < 0) + { + this._stream.writeBool(false); + this._stream.writeString(typeId); + } + else + { + this._stream.writeBool(true); + this._stream.writeSize(index); + } + } + else + { + this._stream.writeString(typeId); + } + + this._stream.writeInt(0); // Placeholder for the slice length. + + this._writeSlice = this._stream.pos; + }, + endSlice: function() + { + // + // Write the slice length. + // + var sz = this._stream.pos - this._writeSlice + 4; + this._stream.rewriteInt(sz, this._writeSlice - 4); + }, + writePendingObjects: function() + { + var self = this, + writeCB = function(key, value) + { + // + // Ask the instance to marshal itself. Any new class + // instances that are triggered by the classes marshaled + // are added to toBeMarshaledMap. + // + self._stream.writeInt(value); + + try + { + key.ice_preMarshal(); + } + catch(ex) + { + self._stream.instance.initializationData().logger.warning( + "exception raised by ice_preMarshal:\n" + ExUtil.toString(ex)); + } + + key.__write(self._stream); + }, + savedMap; + + while(this._toBeMarshaledMap.size > 0) + { + // + // Consider the to be marshalled objects as marshalled now, + // this is necessary to avoid adding again the "to be + // marshalled objects" into _toBeMarshaledMap while writing + // objects. + // + this._marshaledMap.merge(this._toBeMarshaledMap); + + savedMap = this._toBeMarshaledMap; + this._toBeMarshaledMap = new HashMap(); // HashMap<Ice.Object, int>(); + this._stream.writeSize(savedMap.size); + savedMap.forEach(writeCB); + } + this._stream.writeSize(0); // Zero marker indicates end of sequence of sequences of instances. + }, + registerObject: function(v) + { + Debug.assert(v !== null); + + // + // Look for this instance in the to-be-marshaled map. + // + var p = this._toBeMarshaledMap.get(v); + if(p !== undefined) + { + return p; + } + + // + // Didn't find it, try the marshaled map next. + // + p = this._marshaledMap.get(v); + if(p !== undefined) + { + return p; + } + + // + // We haven't seen this instance previously, create a new + // index, and insert it into the to-be-marshaled map. + // + this._toBeMarshaledMap.set(v, ++this._objectIdIndex); + return this._objectIdIndex; + } + }); + + var EncapsEncoder11 = Class(EncapsEncoder, { + __init__: function(stream, encaps) + { + EncapsEncoder.call(this, stream, encaps); + this._current = null; + this._objectIdIndex = 1; + }, + writeObject: function(v) + { + Debug.assert(v !== undefined); + var index, idx; + if(v === null) + { + this._stream.writeSize(0); + } + else if(this._current !== null && this._encaps.format === FormatType.SlicedFormat) + { + if(this._current.indirectionTable === null) // Lazy initialization + { + this._current.indirectionTable = []; // Ice.Object[] + this._current.indirectionMap = new HashMap(); // HashMap<Ice.Object, int> + } + + // + // If writting an object within a slice and using the sliced + // format, write an index from the object indirection + // table. The indirect object table is encoded at the end of + // each slice and is always read (even if the Slice is + // unknown). + // + index = this._current.indirectionMap.get(v); + if(index === undefined) + { + this._current.indirectionTable.push(v); + idx = this._current.indirectionTable.length; // Position + 1 (0 is reserved for nil) + this._current.indirectionMap.set(v, idx); + this._stream.writeSize(idx); + } + else + { + this._stream.writeSize(index); + } + } + else + { + this.writeInstance(v); // Write the instance or a reference if already marshaled. + } + }, + writePendingObjects: function() + { + return undefined; + }, + writeUserException: function(v) + { + Debug.assert(v !== null && v !== undefined); + v.__write(this._stream); + }, + startInstance: function(sliceType, data) + { + if(this._current === null) + { + this._current = new EncapsEncoder11.InstanceData(null); + } + else + { + this._current = (this._current.next === null) ? new EncapsEncoder11.InstanceData(this._current) : this._current.next; + } + this._current.sliceType = sliceType; + this._current.firstSlice = true; + + if(data !== null && data !== undefined) + { + this.writeSlicedData(data); + } + }, + endInstance: function() + { + this._current = this._current.previous; + }, + startSlice: function(typeId, compactId, last) + { + Debug.assert((this._current.indirectionTable === null || this._current.indirectionTable.length === 0) && + (this._current.indirectionMap === null || this._current.indirectionMap.size === 0)); + + this._current.sliceFlagsPos = this._stream.pos; + + this._current.sliceFlags = 0; + if(this._encaps.format === FormatType.SlicedFormat) + { + this._current.sliceFlags |= FLAG_HAS_SLICE_SIZE; // Encode the slice size if using the sliced format. + } + if(last) + { + this._current.sliceFlags |= FLAG_IS_LAST_SLICE; // This is the last slice. + } + + this._stream.writeByte(0); // Placeholder for the slice flags + + // + // For object slices, encode the flag and the type ID either as a + // string or index. For exception slices, always encode the type + // ID a string. + // + if(this._current.sliceType === SliceType.ObjectSlice) + { + // + // Encode the type ID (only in the first slice for the compact + // encoding). + // + if(this._encaps.format === FormatType.SlicedFormat || this._current.firstSlice) + { + if(compactId >= 0) + { + this._current.sliceFlags |= FLAG_HAS_TYPE_ID_COMPACT; + this._stream.writeSize(compactId); + } + else + { + var index = this.registerTypeId(typeId); + if(index < 0) + { + this._current.sliceFlags |= FLAG_HAS_TYPE_ID_STRING; + this._stream.writeString(typeId); + } + else + { + this._current.sliceFlags |= FLAG_HAS_TYPE_ID_INDEX; + this._stream.writeSize(index); + } + } + } + } + else + { + this._stream.writeString(typeId); + } + + if((this._current.sliceFlags & FLAG_HAS_SLICE_SIZE) !== 0) + { + this._stream.writeInt(0); // Placeholder for the slice length. + } + + this._current.writeSlice = this._stream.pos; + this._current.firstSlice = false; + }, + endSlice: function() + { + var sz, i, length; + + // + // Write the optional member end marker if some optional members + // were encoded. Note that the optional members are encoded before + // the indirection table and are included in the slice size. + // + if((this._current.sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) !== 0) + { + this._stream.writeByte(OPTIONAL_END_MARKER); + } + + // + // Write the slice length if necessary. + // + if((this._current.sliceFlags & FLAG_HAS_SLICE_SIZE) !== 0) + { + sz = this._stream.pos - this._current.writeSlice + 4; + this._stream.rewriteInt(sz, this._current.writeSlice - 4); + } + + // + // Only write the indirection table if it contains entries. + // + if(this._current.indirectionTable !== null && this._current.indirectionTable.length !== 0) + { + Debug.assert(this._encaps.format === FormatType.SlicedFormat); + this._current.sliceFlags |= FLAG_HAS_INDIRECTION_TABLE; + + // + // Write the indirection object table. + // + this._stream.writeSize(this._current.indirectionTable.length); + for(i = 0, length = this._current.indirectionTable.length; i < length; ++i) + { + this.writeInstance(this._current.indirectionTable[i]); + } + this._current.indirectionTable.length = 0; // Faster way to clean array in JavaScript + this._current.indirectionMap.clear(); + } + + // + // Finally, update the slice flags. + // + this._stream.rewriteByte(this._current.sliceFlags, this._current.sliceFlagsPos); + }, + writeOpt: function(tag, format) + { + if(this._current === null) + { + return this._stream.writeOptImpl(tag, format); + } + + if(this._stream.writeOptImpl(tag, format)) + { + this._current.sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS; + return true; + } + + return false; + }, + writeSlicedData: function(slicedData) + { + Debug.assert(slicedData !== null && slicedData !== undefined); + + // + // We only remarshal preserved slices if we are using the sliced + // format. Otherwise, we ignore the preserved slices, which + // essentially "slices" the object into the most-derived type + // known by the sender. + // + if(this._encaps.format !== FormatType.SlicedFormat) + { + return; + } + + var i, ii, info, + j, jj; + + for(i = 0, ii = slicedData.slices.length; i < ii; ++i) + { + info = slicedData.slices[i]; + this.startSlice(info.typeId, info.compactId, info.isLastSlice); + + // + // Write the bytes associated with this slice. + // + this._stream.writeBlob(info.bytes); + + if(info.hasOptionalMembers) + { + this._current.sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS; + } + + // + // Make sure to also re-write the object indirection table. + // + if(info.objects !== null && info.objects.length > 0) + { + if(this._current.indirectionTable === null) // Lazy initialization + { + this._current.indirectionTable = []; // Ice.Object[] + this._current.indirectionMap = new HashMap(); // HashMap<Ice.Object, int> + } + + for(j = 0, jj = info.objects.length; j < jj; ++j) + { + this._current.indirectionTable.push(info.objects[j]); + } + } + + this.endSlice(); + } + }, + writeInstance: function(v) + { + Debug.assert(v !== null && v !== undefined); + + // + // If the instance was already marshaled, just write it's ID. + // + var p = this._marshaledMap.get(v); + if(p !== undefined) + { + this._stream.writeSize(p); + return; + } + + // + // We haven't seen this instance previously, create a new ID, + // insert it into the marshaled map, and write the instance. + // + this._marshaledMap.set(v, ++this._objectIdIndex); + + try + { + v.ice_preMarshal(); + } + catch(ex) + { + this._stream.instance.initializationData().logger.warning("exception raised by ice_preMarshal:\n" + + ExUtil.toString(ex)); + } + + this._stream.writeSize(1); // Object instance marker. + v.__write(this._stream); + } + }); + + EncapsEncoder11.InstanceData = function(previous) + { + Debug.assert(previous !== undefined); + if(previous !== null) + { + previous.next = this; + } + this.previous = previous; + this.next = null; + + // Instance attributes + this.sliceType = null; + this.firstSlice = false; + + // Slice attributes + this.sliceFlags = 0; + this.writeSlice = 0; // Position of the slice data members + this.sliceFlagsPos = 0; // Position of the slice flags + this.indirectionTable = null; // Ice.Object[] + this.indirectionMap = null; // HashMap<Ice.Object, int> + }; + + var ReadEncaps = Class({ + __init__: function() + { + this.start = 0; + this.sz = 0; + this.encoding = null; + this.encoding_1_0 = false; + this.decoder = null; + this.next = null; + }, + reset: function() + { + this.decoder = null; + }, + setEncoding: function(encoding) + { + this.encoding = encoding; + this.encoding_1_0 = encoding.equals(Ice.Encoding_1_0); + } + }); + + var WriteEncaps = Class({ + __init__: function() + { + this.start = 0; + this.format = FormatType.DefaultFormat; + this.encoding = null; + this.encoding_1_0 = false; + this.encoder = null; + this.next = null; + }, + reset: function() + { + this.encoder = null; + }, + setEncoding: function(encoding) + { + this.encoding = encoding; + this.encoding_1_0 = encoding.equals(Ice.Encoding_1_0); + } + }); + + var BasicStream = Class({ + __init__: function(instance, encoding, unlimited, data) + { + this._instance = instance; + this._closure = null; + this._encoding = encoding; + + this._readEncapsStack = null; + this._writeEncapsStack = null; + this._readEncapsCache = null; + this._writeEncapsCache = null; + + this._sliceObjects = true; + + this._messageSizeMax = this._instance.messageSizeMax(); // Cached for efficiency. + this._unlimited = unlimited !== undefined ? unlimited : false; + + this._startSeq = -1; + this._sizePos = -1; + + if(data !== undefined) + { + this._buf = new Ice.Buffer(data); + } + else + { + this._buf = new Ice.Buffer(); + } + }, + // + // This function allows this object to be reused, rather than + // reallocated. + // + reset: function() + { + this._buf.reset(); + this.clear(); + }, + clear: function() + { + if(this._readEncapsStack !== null) + { + Debug.assert(this._readEncapsStack.next); + this._readEncapsStack.next = this._readEncapsCache; + this._readEncapsCache = this._readEncapsStack; + this._readEncapsCache.reset(); + this._readEncapsStack = null; + } + + if(this._writeEncapsStack !== null) + { + Debug.assert(this._writeEncapsStack.next); + this._writeEncapsStack.next = this._writeEncapsCache; + this._writeEncapsCache = this._writeEncapsStack; + this._writeEncapsCache.reset(); + this._writeEncapsStack = null; + } + this._startSeq = -1; + this._sliceObjects = true; + }, + swap: function(other) + { + Debug.assert(this._instance === other._instance); + + var tmpBuf, tmpClosure, tmpUnlimited, tmpStartSeq, tmpMinSeqSize, tmpSizePos; + + tmpBuf = other._buf; + other._buf = this._buf; + this._buf = tmpBuf; + + tmpClosure = other._closure; + other._closure = this._closure; + this._closure = tmpClosure; + + // + // Swap is never called for BasicStreams that have encapsulations being read/write. However, + // encapsulations might still be set in case marshalling or un-marshalling failed. We just + // reset the encapsulations if there are still some set. + // + this.resetEncaps(); + other.resetEncaps(); + + tmpUnlimited = other._unlimited; + other._unlimited = this._unlimited; + this._unlimited = tmpUnlimited; + + tmpStartSeq = other._startSeq; + other._startSeq = this._startSeq; + this._startSeq = tmpStartSeq; + + tmpMinSeqSize = other._minSeqSize; + other._minSeqSize = this._minSeqSize; + this._minSeqSize = tmpMinSeqSize; + + tmpSizePos = other._sizePos; + other._sizePos = this._sizePos; + this._sizePos = tmpSizePos; + }, + resetEncaps: function() + { + this._readEncapsStack = null; + this._writeEncapsStack = null; + }, + resize: function(sz) + { + // + // Check memory limit if stream is not unlimited. + // + if(!this._unlimited && sz > this._messageSizeMax) + { + ExUtil.throwMemoryLimitException(sz, this._messageSizeMax); + } + + this._buf.resize(sz); + this._buf.position = sz; + }, + prepareWrite: function() + { + this._buf.position = 0; + return this._buf; + }, + startWriteObject: function(data) + { + Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null); + this._writeEncapsStack.encoder.startInstance(SliceType.ObjectSlice, data); + }, + endWriteObject: function() + { + Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null); + this._writeEncapsStack.encoder.endInstance(); + }, + startReadObject: function() + { + Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null); + this._readEncapsStack.decoder.startInstance(SliceType.ObjectSlice); + }, + endReadObject: function(preserve) + { + Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null); + return this._readEncapsStack.decoder.endInstance(preserve); + }, + startWriteException: function(data) + { + Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null); + this._writeEncapsStack.encoder.startInstance(SliceType.ExceptionSlice, data); + }, + endWriteException: function() + { + Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null); + this._writeEncapsStack.encoder.endInstance(); + }, + startReadException: function() + { + Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null); + this._readEncapsStack.decoder.startInstance(SliceType.ExceptionSlice); + }, + endReadException: function(preserve) + { + Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null); + return this._readEncapsStack.decoder.endInstance(preserve); + }, + startWriteEncaps: function(encoding, format) + { + // + // If no encoding version is specified, use the current write + // encapsulation encoding version if there's a current write + // encapsulation, otherwise, use the stream encoding version. + // + + if(encoding === undefined) + { + if(this._writeEncapsStack !== null) + { + encoding = this._writeEncapsStack.encoding; + format = this._writeEncapsStack.format; + } + else + { + encoding = this._encoding; + format = FormatType.DefaultFormat; + } + } + + Protocol.checkSupportedEncoding(encoding); + + var curr = this._writeEncapsCache; + if(curr !== null) + { + curr.reset(); + this._writeEncapsCache = this._writeEncapsCache.next; + } + else + { + curr = new WriteEncaps(); + } + curr.next = this._writeEncapsStack; + this._writeEncapsStack = curr; + + this._writeEncapsStack.format = format; + this._writeEncapsStack.setEncoding(encoding); + this._writeEncapsStack.start = this._buf.limit; + + this.writeInt(0); // Placeholder for the encapsulation length. + this._writeEncapsStack.encoding.__write(this); + }, + endWriteEncaps: function() + { + Debug.assert(this._writeEncapsStack); + + // Size includes size and version. + var start = this._writeEncapsStack.start; + + var sz = this._buf.limit - start; + this._buf.putIntAt(start, sz); + + var curr = this._writeEncapsStack; + this._writeEncapsStack = curr.next; + curr.next = this._writeEncapsCache; + this._writeEncapsCache = curr; + this._writeEncapsCache.reset(); + }, + endWriteEncapsChecked: function() // Used by public stream API. + { + if(this._writeEncapsStack === null) + { + throw new Ice.EncapsulationException("not in an encapsulation"); + } + this.endWriteEncaps(); + }, + writeEmptyEncaps: function(encoding) + { + Protocol.checkSupportedEncoding(encoding); + this.writeInt(6); // Size + encoding.__write(this); + }, + writeEncaps: function(v) + { + if(v.length < 6) + { + throw new Ice.EncapsulationException(); + } + this.expand(v.length); + this._buf.putArray(v); + }, + getWriteEncoding: function() + { + return this._writeEncapsStack !== null ? this._writeEncapsStack.encoding : this._encoding; + }, + startReadEncaps: function() + { + var curr = this._readEncapsCache; + if(curr !== null) + { + curr.reset(); + this._readEncapsCache = this._readEncapsCache.next; + } + else + { + curr = new ReadEncaps(); + } + curr.next = this._readEncapsStack; + this._readEncapsStack = curr; + + this._readEncapsStack.start = this._buf.position; + + // + // I don't use readSize() and writeSize() for encapsulations, + // because when creating an encapsulation, I must know in advance + // how many bytes the size information will require in the data + // stream. If I use an Int, it is always 4 bytes. For + // readSize()/writeSize(), it could be 1 or 5 bytes. + // + var sz = this.readInt(); + if(sz < 6) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + if(sz - 4 > this._buf.remaining) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + this._readEncapsStack.sz = sz; + + var encoding = new Ice.EncodingVersion(); + encoding.__read(this); + Protocol.checkSupportedEncoding(encoding); // Make sure the encoding is supported. + this._readEncapsStack.setEncoding(encoding); + + return encoding; + }, + endReadEncaps: function() + { + Debug.assert(this._readEncapsStack !== null); + + if(!this._readEncapsStack.encoding_1_0) + { + this.skipOpts(); + if(this._buf.position !== this._readEncapsStack.start + this._readEncapsStack.sz) + { + throw new Ice.EncapsulationException(); + } + } + else if(this._buf.position !== this._readEncapsStack.start + this._readEncapsStack.sz) + { + if(this._buf.position + 1 !== this._readEncapsStack.start + this._readEncapsStack.sz) + { + throw new Ice.EncapsulationException(); + } + + // + // Ice version < 3.3 had a bug where user exceptions with + // class members could be encoded with a trailing byte + // when dispatched with AMD. So we tolerate an extra byte + // in the encapsulation. + // + + try + { + this._buf.get(); + } + catch(ex) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + } + + var curr = this._readEncapsStack; + this._readEncapsStack = curr.next; + curr.next = this._readEncapsCache; + this._readEncapsCache = curr; + this._readEncapsCache.reset(); + }, + skipEmptyEncaps: function(encoding) + { + Debug.assert(encoding !== undefined); + var sz = this.readInt(); + if(sz !== 6) + { + throw new Ice.EncapsulationException(); + } + + var pos = this._buf.position; + if(pos + 2 > this._buf.limit) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + + if(encoding !== null) + { + encoding.__read(this); + } + else + { + this._buf.position = pos + 2; + } + }, + endReadEncapsChecked: function() // Used by public stream API. + { + if(this._readEncapsStack === null) + { + throw new Ice.EncapsulationException("not in an encapsulation"); + } + this.endReadEncaps(); + }, + readEncaps: function(encoding) + { + Debug.assert(encoding !== undefined); + var sz = this.readInt(); + if(sz < 6) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + + if(sz - 4 > this._buf.remaining) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + + if(encoding !== null) + { + encoding.__read(this); + this._buf.position = this._buf.position - 6; + } + else + { + this._buf.position = this._buf.position - 4; + } + + try + { + return this._buf.getArray(sz); + } + catch(ex) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + }, + getReadEncoding: function() + { + return this._readEncapsStack !== null ? this._readEncapsStack.encoding : this._encoding; + }, + getReadEncapsSize: function() + { + Debug.assert(this._readEncapsStack !== null); + return this._readEncapsStack.sz - 6; + }, + skipEncaps: function() + { + var sz = this.readInt(); + if(sz < 6) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + var encoding = new Ice.EncodingVersion(); + encoding.__read(this); + try + { + this._buf.position = this._buf.position + sz - 6; + } + catch(ex) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + return encoding; + }, + startWriteSlice: function(typeId, compactId, last) + { + Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null); + this._writeEncapsStack.encoder.startSlice(typeId, compactId, last); + }, + endWriteSlice: function() + { + Debug.assert(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null); + this._writeEncapsStack.encoder.endSlice(); + }, + startReadSlice: function() // Returns type ID of next slice + { + Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null); + return this._readEncapsStack.decoder.startSlice(); + }, + endReadSlice: function() + { + Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null); + this._readEncapsStack.decoder.endSlice(); + }, + skipSlice: function() + { + Debug.assert(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null); + this._readEncapsStack.decoder.skipSlice(); + }, + readPendingObjects: function() + { + if(this._readEncapsStack !== null && this._readEncapsStack.decoder !== null) + { + this._readEncapsStack.decoder.readPendingObjects(); + } + else if((this._readEncapsStack !== null && this._readEncapsStack.encoding_1_0) || + (this._readEncapsStack === null && this._encoding.equals(Ice.Encoding_1_0))) + { + // + // If using the 1.0 encoding and no objects were read, we + // still read an empty sequence of pending objects if + // requested (i.e.: if this is called). + // + // This is required by the 1.0 encoding, even if no objects + // are written we do marshal an empty sequence if marshaled + // data types use classes. + // + this.skipSize(); + } + }, + writePendingObjects: function() + { + if(this._writeEncapsStack !== null && this._writeEncapsStack.encoder !== null) + { + this._writeEncapsStack.encoder.writePendingObjects(); + } + else if((this._writeEncapsStack !== null && this._writeEncapsStack.encoding_1_0) || + (this._writeEncapsStack === null && this._encoding.equals(Ice.Encoding_1_0))) + { + // + // If using the 1.0 encoding and no objects were written, we + // still write an empty sequence for pending objects if + // requested (i.e.: if this is called). + // + // This is required by the 1.0 encoding, even if no objects + // are written we do marshal an empty sequence if marshaled + // data types use classes. + // + this.writeSize(0); + } + }, + writeSize: function(v) + { + if(v > 254) + { + this.expand(5); + this._buf.put(255); + this._buf.putInt(v); + } + else + { + this.expand(1); + this._buf.put(v); + } + }, + readSize: function() + { + try + { + var b = this._buf.get(); + if(b === 255) + { + var v = this._buf.getInt(); + if(v < 0) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + return v; + } + return b; + } + catch(ex) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + }, + readAndCheckSeqSize: function(minSize) + { + var sz = this.readSize(); + + if(sz === 0) + { + return sz; + } + + // + // The _startSeq variable points to the start of the sequence for which + // we expect to read at least _minSeqSize bytes from the stream. + // + // If not initialized or if we already read more data than _minSeqSize, + // we reset _startSeq and _minSeqSize for this sequence (possibly a + // top-level sequence or enclosed sequence it doesn't really matter). + // + // Otherwise, we are reading an enclosed sequence and we have to bump + // _minSeqSize by the minimum size that this sequence will require on + // the stream. + // + // The goal of this check is to ensure that when we start un-marshalling + // a new sequence, we check the minimal size of this new sequence against + // the estimated remaining buffer size. This estimatation is based on + // the minimum size of the enclosing sequences, it's _minSeqSize. + // + if(this._startSeq === -1 || this._buf.position > (this._startSeq + this._minSeqSize)) + { + this._startSeq = this._buf.position; + this._minSeqSize = sz * minSize; + } + else + { + this._minSeqSize += sz * minSize; + } + + // + // If there isn't enough data to read on the stream for the sequence (and + // possibly enclosed sequences), something is wrong with the marshalled + // data: it's claiming having more data that what is possible to read. + // + if(this._startSeq + this._minSeqSize > this._buf.limit) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + + return sz; + }, + startSize: function() + { + var pos = this._buf.position; + this.writeInt(0); // Placeholder for 32-bit size + return pos; + }, + endSize: function(pos) + { + Debug.assert(pos >= 0); + this.rewriteInt(this._buf.position - pos - 4, pos); + }, + writeBlob: function(v) + { + if(v === null) + { + return; + } + this.expand(v.length); + this._buf.putArray(v); + }, + readBlob: function(sz) + { + if(this._buf.remaining < sz) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + try + { + return this._buf.getArray(sz); + } + catch(ex) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + }, + // Read/write format and tag for optionals + writeOpt: function(tag, format) + { + Debug.assert(this._writeEncapsStack !== null); + if(this._writeEncapsStack.encoder !== null) + { + return this._writeEncapsStack.encoder.writeOpt(tag, format); + } + return this.writeOptImpl(tag, format); + }, + readOpt: function(tag, expectedFormat) + { + Debug.assert(this._readEncapsStack !== null); + if(this._readEncapsStack.decoder !== null) + { + return this._readEncapsStack.decoder.readOpt(tag, expectedFormat); + } + return this.readOptImpl(tag, expectedFormat); + }, + writeOptValue: function(tag, format, write, v) + { + if(v !== undefined) + { + if(this.writeOpt(tag, format)) + { + write.call(this, v); + } + } + }, + readOptValue: function(tag, format, read) + { + if(this.readOpt(tag, format)) + { + return read.call(this); + } + else + { + return undefined; + } + }, + writeByte: function(v) + { + this.expand(1); + this._buf.put(v); + }, + rewriteByte: function(v, dest) + { + this._buf.putAt(dest, v); + }, + readByte: function() + { + try + { + return this._buf.get(); + } + catch(ex) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + }, + writeByteSeq: function(v) + { + if(v === null || v.length === 0) + { + this.writeSize(0); + } + else + { + this.writeSize(v.length); + this.expand(v.length); + this._buf.putArray(v); + } + }, + readByteSeq: function() + { + return this._buf.getArray(this.readAndCheckSeqSize(1)); + }, + writeBool: function(v) + { + this.expand(1); + this._buf.put(v ? 1 : 0); + }, + rewriteBool: function(v, dest) + { + this._buf.putAt(dest, v ? 1 : 0); + }, + readBool: function() + { + try + { + return this._buf.get() === 1; + } + catch(ex) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + }, + writeShort: function(v) + { + this.expand(2); + this._buf.putShort(v); + }, + readShort: function() + { + try + { + return this._buf.getShort(); + } + catch(ex) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + }, + writeInt: function(v) + { + this.expand(4); + this._buf.putInt(v); + }, + rewriteInt: function(v, dest) + { + this._buf.putIntAt(dest, v); + }, + readInt: function() + { + try + { + return this._buf.getInt(); + } + catch(ex) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + }, + writeLong: function(v) + { + this.expand(8); + this._buf.putLong(v); + }, + readLong: function() + { + try + { + return this._buf.getLong(); + } + catch(ex) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + }, + writeFloat: function(v) + { + this.expand(4); + this._buf.putFloat(v); + }, + readFloat: function() + { + try + { + return this._buf.getFloat(); + } + catch(ex) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + }, + writeDouble: function(v) + { + this.expand(8); + this._buf.putDouble(v); + }, + readDouble: function() + { + try + { + return this._buf.getDouble(); + } + catch(ex) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + }, + writeString: function(v) + { + if(v === null || v.length === 0) + { + this.writeSize(0); + } + else + { + this._buf.writeString(this, v); + } + }, + readString: function() + { + var len = this.readSize(); + if(len === 0) + { + return ""; + } + // + // Check the buffer has enough bytes to read. + // + if(this._buf.remaining < len) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + + try + { + return this._buf.getString(len); + } + catch(ex) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + }, + writeProxy: function(v) + { + this._instance.proxyFactory().proxyToStream(v, this); + }, + writeOptProxy: function(tag, v) + { + if(v !== undefined) + { + if(this.writeOpt(tag, OptionalFormat.FSize)) + { + var pos = this.startSize(); + this.writeProxy(v); + this.endSize(pos); + } + } + }, + readProxy: function(type) + { + return this._instance.proxyFactory().streamToProxy(this, type); + }, + readOptProxy: function(tag, type) + { + if(this.readOpt(tag, OptionalFormat.FSize)) + { + this.skip(4); + return this.readProxy(type); + } + else + { + return undefined; + } + }, + writeEnum: function(v) + { + if(this.isWriteEncoding_1_0()) + { + if(v.maxValue < 127) + { + this.writeByte(v.value); + } + else if(v.maxValue < 32767) + { + this.writeShort(v.value); + } + else + { + this.writeInt(v.value); + } + } + else + { + this.writeSize(v.value); + } + }, + readEnum: function(T) + { + var v; + if(this.getReadEncoding().equals(Ice.Encoding_1_0)) + { + if(T.maxValue < 127) + { + v = this.readByte(); + } + else if(T.maxValue < 32767) + { + v = this.readShort(); + } + else + { + v = this.readInt(); + } + } + else + { + v = this.readSize(); + } + + var e = T.valueOf(v); + if(e === undefined) + { + throw new Ice.MarshalException("enumerator value " + v + " is out of range"); + } + return e; + }, + readOptEnum: function(tag, T) + { + if(this.readOpt(tag, OptionalFormat.Size)) + { + return this.readEnum(T); + } + else + { + return undefined; + } + }, + writeObject: function(v) + { + this.initWriteEncaps(); + this._writeEncapsStack.encoder.writeObject(v); + }, + writeOptObject: function(tag, v) + { + if(v !== undefined) + { + if(this.writeOpt(tag, OptionalFormat.Class)) + { + this.writeObject(v); + } + } + }, + readObject: function(patcher, T) + { + this.initReadEncaps(); + // + // BUGFIX: + // With Chrome linux the invokation of readObject on the decoder some times + // calls BasicStream.readObject with the decoder object as this param. + // Use call instead of directly invoke the method to workaround this bug. + // + this._readEncapsStack.decoder.readObject.call( + this._readEncapsStack.decoder, + function(obj){ + if(obj !== null && !(obj.ice_instanceof(T))) + { + ExUtil.throwUOE(T.ice_staticId(), obj); + } + patcher(obj); + }); + }, + readOptObject: function(tag, patcher, T) + { + if(this.readOpt(tag, OptionalFormat.Class)) + { + this.readObject(patcher, T); + } + else + { + patcher(undefined); + } + }, + writeUserException: function(e) + { + this.initWriteEncaps(); + this._writeEncapsStack.encoder.writeUserException(e); + }, + throwException: function() + { + this.initReadEncaps(); + this._readEncapsStack.decoder.throwException(); + }, + sliceObjects: function(b) + { + this._sliceObjects = b; + }, + readOptImpl: function(readTag, expectedFormat) + { + var b, v, format, tag, offset; + + if(this.isReadEncoding_1_0()) + { + return false; // Optional members aren't supported with the 1.0 encoding. + } + + while(true) + { + if(this._buf.position >= this._readEncapsStack.start + this._readEncapsStack.sz) + { + return false; // End of encapsulation also indicates end of optionals. + } + + v = this.readByte(); + + if(v === OPTIONAL_END_MARKER) + { + this._buf.position -= 1; // Rewind. + return false; + } + + format = OptionalFormat.valueOf(v & 0x07); // First 3 bits. + tag = v >> 3; + if(tag === 30) + { + tag = this.readSize(); + } + + if(tag > readTag) + { + offset = tag < 30 ? 1 : (tag < 255 ? 2 : 6); // Rewind + this._buf.position -= offset; + return false; // No optional data members with the requested tag. + } + + if(tag < readTag) + { + this.skipOpt(format); // Skip optional data members + } + else + { + if(format !== expectedFormat) + { + throw new Ice.MarshalException("invalid optional data member `" + tag + "': unexpected format"); + } + return true; + } + } + }, + writeOptImpl: function(tag, format) + { + if(this.isWriteEncoding_1_0()) + { + return false; // Optional members aren't supported with the 1.0 encoding. + } + + var v = format.value; + if(tag < 30) + { + v |= tag << 3; + this.writeByte(v); + } + else + { + v |= 0x0F0; // tag = 30 + this.writeByte(v); + this.writeSize(tag); + } + return true; + }, + skipOpt: function(format) + { + switch(format) + { + case OptionalFormat.F1: + this.skip(1); + break; + case OptionalFormat.F2: + this.skip(2); + break; + case OptionalFormat.F4: + this.skip(4); + break; + case OptionalFormat.F8: + this.skip(8); + break; + case OptionalFormat.Size: + this.skipSize(); + break; + case OptionalFormat.VSize: + this.skip(this.readSize()); + break; + case OptionalFormat.FSize: + this.skip(this.readInt()); + break; + case OptionalFormat.Class: + this.readObject(null, Ice.Object); + break; + } + }, + skipOpts: function() + { + var b, v, format; + // + // Skip remaining un-read optional members. + // + while(true) + { + if(this._buf.position >= this._readEncapsStack.start + this._readEncapsStack.sz) + { + return; // End of encapsulation also indicates end of optionals. + } + + b = this.readByte(); + v = b < 0 ? b + 256 : b; + if(v === OPTIONAL_END_MARKER) + { + return; + } + + format = OptionalFormat.valueOf(v & 0x07); // Read first 3 bits. + if((v >> 3) === 30) + { + this.skipSize(); + } + this.skipOpt(format); + } + }, + skip: function(size) + { + if(size > this._buf.remaining) + { + throw new Ice.UnmarshalOutOfBoundsException(); + } + this._buf.position += size; + }, + skipSize: function() + { + var b = this.readByte(); + if(b === 255) + { + this.skip(4); + } + }, + isEmpty: function() + { + return this._buf.empty(); + }, + expand: function(n) + { + if(!this._unlimited && this._buf && this._buf.position + n > this._messageSizeMax) + { + ExUtil.throwMemoryLimitException(this._buf.position + n, this._messageSizeMax); + } + this._buf.expand(n); + }, + createObject: function(id) + { + var obj = null, Class; + try + { + var typeId = id.length > 2 ? id.substr(2).replace("::", ".") : ""; + /*jshint -W061 */ + Class = eval(typeId); + /*jshint +W061 */ + if(Class !== undefined) + { + obj = new Class(); + } + } + catch(ex) + { + throw new Ice.NoObjectFactoryException("no object factory", id, ex); + } + + return obj; + }, + getTypeId: function(compactId) + { + var typeId = Ice.CompactIdRegistry.get(compactId); + return typeId === undefined ? "" : typeId; + }, + isReadEncoding_1_0: function() + { + return this._readEncapsStack !== null ? this._readEncapsStack.encoding_1_0 : this._encoding.equals(Ice.Encoding_1_0); + }, + isWriteEncoding_1_0: function() + { + return this._writeEncapsStack ? this._writeEncapsStack.encoding_1_0 : this._encoding.equals(Ice.Encoding_1_0); + }, + initReadEncaps: function() + { + if(this._readEncapsStack === null) // Lazy initialization + { + this._readEncapsStack = this._readEncapsCache; + if(this._readEncapsStack !== null) + { + this._readEncapsCache = this._readEncapsCache.next; + } + else + { + this._readEncapsStack = new ReadEncaps(); + } + this._readEncapsStack.setEncoding(this._encoding); + this._readEncapsStack.sz = this._buf.limit; + } + + if(this._readEncapsStack.decoder === null) // Lazy initialization. + { + var factoryManager = this._instance.servantFactoryManager(); + if(this._readEncapsStack.encoding_1_0) + { + this._readEncapsStack.decoder = new EncapsDecoder10(this, this._readEncapsStack, this._sliceObjects, factoryManager); + } + else + { + this._readEncapsStack.decoder = new EncapsDecoder11(this, this._readEncapsStack, this._sliceObjects, factoryManager); + } + } + }, + initWriteEncaps: function() + { + if(!this._writeEncapsStack) // Lazy initialization + { + this._writeEncapsStack = this._writeEncapsCache; + if(this._writeEncapsStack) + { + this._writeEncapsCache = this._writeEncapsCache.next; + } + else + { + this._writeEncapsStack = new WriteEncaps(); + } + this._writeEncapsStack.setEncoding(this._encoding); + } + + if(this._writeEncapsStack.format === FormatType.DefaultFormat) + { + this._writeEncapsStack.format = this._instance.defaultsAndOverrides().defaultFormat; + } + + if(!this._writeEncapsStack.encoder) // Lazy initialization. + { + if(this._writeEncapsStack.encoding_1_0) + { + this._writeEncapsStack.encoder = new EncapsEncoder10(this, this._writeEncapsStack); + } + else + { + this._writeEncapsStack.encoder = new EncapsEncoder11(this, this._writeEncapsStack); + } + } + }, + createUserException: function(id) + { + var userEx = null, Class; + + try + { + var typeId = id.length > 2 ? id.substr(2).replace("::", ".") : ""; + /*jshint -W061 */ + Class = eval(typeId); + /*jshint +W061 */ + if(Class !== undefined) + { + userEx = new Class(); + } + } + catch(ex) + { + throw new Ice.MarshalException(ex); + } + + return userEx; + } + }); + + var defineProperty = Object.defineProperty; + + defineProperty(BasicStream.prototype, "pos", { + get: function() { return this._buf.position; }, + set: function(n) { this._buf.position = n; } + }); + + defineProperty(BasicStream.prototype, "size", { + get: function() { return this._buf.limit; } + }); + + defineProperty(BasicStream.prototype, "instance", { + get: function() { return this._instance; } + }); + + defineProperty(BasicStream.prototype, "closure", { + get: function() { return this._type; }, + set: function(type) { this._type = type; } + }); + + defineProperty(BasicStream.prototype, "buffer", { + get: function() { return this._buf; } + }); + + var defineBuiltinHelper = function(write, read, sz, format) + { + var helper = { + write: function(os, v) { return write.call(os, v); }, + read: function(is) { return read.call(is); }, + writeOpt: function(os, tag, v) { os.writeOptValue(tag, format, write, v); }, + readOpt: function(is, tag) { return is.readOptValue(tag, format, read); }, + }; + defineProperty(helper, "minWireSize", { + get: function() { return sz; } + }); + return helper; + }; + + var stream = BasicStream.prototype; + Ice.ByteHelper = defineBuiltinHelper(stream.writeByte, stream.readByte, 1, Ice.OptionalFormat.F1); + Ice.BoolHelper = defineBuiltinHelper(stream.writeBool, stream.readBool, 1, Ice.OptionalFormat.F1); + Ice.ShortHelper = defineBuiltinHelper(stream.writeShort, stream.readShort, 2, Ice.OptionalFormat.F2); + Ice.IntHelper = defineBuiltinHelper(stream.writeInt, stream.readInt, 4, Ice.OptionalFormat.F4); + Ice.LongHelper = defineBuiltinHelper(stream.writeLong, stream.readLong, 8, Ice.OptionalFormat.F8); + Ice.FloatHelper = defineBuiltinHelper(stream.writeFloat, stream.readFloat, 4, Ice.OptionalFormat.F4); + Ice.DoubleHelper = defineBuiltinHelper(stream.writeDouble, stream.readDouble, 8, Ice.OptionalFormat.F8); + Ice.StringHelper = defineBuiltinHelper(stream.writeString, stream.readString, 1, Ice.OptionalFormat.VSize); + + Ice.ObjectHelper = { + write: function(os, v) + { + os.writeObject(v); + }, + read: function(is) + { + var o; + is.readObject(function(v) { o = v; }, Ice.Object); + return o; + }, + writeOpt: function(os, tag, v) + { + os.writeOptValue(tag, Ice.OptionalFormat.Class, stream.writeObject, v); + }, + readOpt: function(is, tag) + { + var o; + is.readOptObject(tag, function(v) { o = v; }, Ice.Object); + return o; + }, + }; + + defineProperty(Ice.ObjectHelper, "minWireSize", { + get: function() { return 1; } + }); + + Ice.BasicStream = BasicStream; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/BatchOutgoingAsync.js b/js/src/Ice/BatchOutgoingAsync.js new file mode 100644 index 00000000000..ccebcad9ba5 --- /dev/null +++ b/js/src/Ice/BatchOutgoingAsync.js @@ -0,0 +1,37 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_FOR_ACTIONSCRIPT_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/AsyncResult"); + + var Ice = global.Ice || {}; + + var AsyncResult = Ice.AsyncResult; + + var BatchOutgoingAsync = Ice.Class(AsyncResult, { + __init__: function(communicator, operation) + { + AsyncResult.call(this, communicator, operation, null, null, null, null); + }, + __sent: function(connection) + { + this._state |= AsyncResult.Done | AsyncResult.OK | AsyncResult.Sent; + this._os.resize(0); + this.succeed(this); + }, + __finishedEx: function(exc, sent) + { + this.__exception(exc); + } + }); + + Ice.BatchOutgoingAsync = BatchOutgoingAsync; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Buffer.js b/js/src/Ice/Buffer.js new file mode 100644 index 00000000000..71c4f614bc6 --- /dev/null +++ b/js/src/Ice/Buffer.js @@ -0,0 +1,429 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +// +// Ice.Buffer implementation to be used by Node.js, it uses node Buffer +// as the store. +// + +// +// Define Node.Buffer as an alias to NodeJS global Buffer type, +// that allow us to refer to Ice.Buffer as Buffer in this file. +// +(function(global){ + var Node = { Buffer: global.Buffer }; + + require("Ice/Long"); + require("Ice/Class"); + + var Ice = global.Ice || {}; + var Long = Ice.Long; + + var __BufferOverflowException__ = "BufferOverflowException"; + var __BufferUnderflowException__ = "BufferUnderflowException"; + var __IndexOutOfBoundsException__ = "IndexOutOfBoundsException"; + + var Buffer = Ice.Class({ + __init__: function(buffer) + { + if(buffer !== undefined) + { + this.b = buffer; + } + else + { + this.b = null; + } + this._position = 0; + this._limit = 0; + this._shrinkCounter = 0; + }, + empty: function() + { + return this._limit === 0; + }, + resize: function(n) + { + if(n === 0) + { + this.clear(); + } + else if(n > this.capacity) + { + this.reserve(n); + } + this._limit = n; + }, + clear: function() + { + this.b = null; + this._position = 0; + this._limit = 0; + }, + // + // Call expand(n) to add room for n additional bytes. Note that expand() + // examines the current position of the buffer first; we don't want to + // expand the buffer if the caller is writing to a location that is + // already in the buffer. + // + expand: function(n) + { + var sz = this.capacity === 0 ? n : this._position + n; + if(sz > this._limit) + { + this.resize(sz); + } + }, + reset: function() + { + if(this._limit > 0 && this._limit * 2 < this.capacity) + { + // + // If the current buffer size is smaller than the + // buffer capacity, we shrink the buffer memory to the + // current size. This is to avoid holding on to too much + // memory if it's not needed anymore. + // + if(++this._shrinkCounter > 2) + { + this.reserve(this._limit); + this._shrinkCounter = 0; + } + } + else + { + this._shrinkCounter = 0; + } + this._limit = 0; + this._position = 0; + }, + reserve: function(n) + { + var b, capacity; + if(n > this.capacity) + { + capacity = Math.max(n, 2 * this.capacity); + capacity = Math.max(1024, capacity); + if(this.b === null) + { + this.b = new Node.Buffer(capacity); + } + else + { + b = new Node.Buffer(capacity); + this.b.copy(b); + this.b = b; + } + } + else if(n < this.capacity) + { + this.b = this.b.slice(0, this.capacity); + } + else + { + return; + } + }, + put: function(v) + { + if(this._position === this._limit) + { + throw new Error(__BufferOverflowException__); + } + this.b.writeUInt8(v, this._position, true); + this._position++; + }, + putAt: function(i, v) + { + if(i >= this._limit) + { + throw new Error(__IndexOutOfBoundsException__); + } + this.b.writeUInt8(v, i, true); + }, + putArray: function(v) + { + //Expects a Nodejs Buffer + if(this._position + v.length > this._limit) + { + throw new Error(__BufferOverflowException__); + } + v.copy(this.b, this._position); + this._position += v.length; + }, + putShort: function(v) + { + if(this._position + 2 > this._limit) + { + throw new Error(__BufferOverflowException__); + } + this.b.writeInt16LE(v, this._position, true); + this._position += 2; + }, + putShortAt: function(i, v) + { + if(i + 2 > this._limit || i < 0) + { + throw new Error(__IndexOutOfBoundsException__); + } + this.b.writeInt16LE(v, i, true); + }, + putInt: function(v) + { + if(this._position + 4 > this._limit) + { + throw new Error(__BufferOverflowException__); + } + this.b.writeInt32LE(v, this._position, true); + this._position += 4; + }, + putIntAt: function(i, v) + { + if(i + 4 > this._limit || i < 0) + { + throw new Error(__IndexOutOfBoundsException__); + } + this.b.writeInt32LE(v, i, true); + }, + putFloat: function(v) + { + if(this._position + 4 > this._limit) + { + throw new Error(__BufferOverflowException__); + } + this.b.writeFloatLE(v, this._position, true); + this._position += 4; + }, + putFloatAt: function(i, v) + { + if(i + 4 > this._limit || i < 0) + { + throw new Error(__IndexOutOfBoundsException__); + } + this.b.writeFloatLE(v, i, true); + }, + putDouble: function(v) + { + if(this._position + 8 > this._limit) + { + throw new Error(__BufferOverflowException__); + } + this.b.writeDoubleLE(v, this._position, true); + this._position += 8; + }, + putDoubleAt: function(i, v) + { + if(i + 8 > this._limit || i < 0) + { + throw new Error(__IndexOutOfBoundsException__); + } + this.b.writeDoubleLE(v, i, true); + }, + putLong: function(v) + { + if(this._position + 8 > this._limit) + { + throw new Error(__BufferOverflowException__); + } + this.b.writeUInt32LE(v.low, this._position, true); + this._position += 4; + this.b.writeUInt32LE(v.high, this._position, true); + this._position += 4; + }, + putLongAt: function(i, v) + { + if(i + 8 > this._limit || i < 0) + { + throw new Error(__IndexOutOfBoundsException__); + } + this.b.writeUInt32LE(v.low, i, true); + this.b.writeUInt32LE(v.high, i + 4, true); + }, + writeString: function(stream, v) + { + var sz = Node.Buffer.byteLength(v); + stream.writeSize(sz); + stream.expand(sz); + this.putString(v, sz); + }, + putString: function(v, sz) + { + if(this._position + sz > this._limit) + { + throw new Error(__BufferOverflowException__); + } + var bytes = this.b.write(v, this._position); + // + // Check all bytes were written + // + if(bytes < sz) + { + throw new Error(__IndexOutOfBoundsException__); + } + this._position += sz; + }, + get: function() + { + if(this._position >= this._limit) + { + throw new Error(__BufferUnderflowException__); + } + var v = this.b.readUInt8(this._position, true); + this._position++; + return v; + }, + getAt: function(i) + { + if(i < 0 || i >= this._limit) + { + throw new Error(__IndexOutOfBoundsException__); + } + return this.b.readUInt8(i, true); + }, + getArray: function(length) + { + if(this._position + length > this._limit) + { + throw new Error(__BufferUnderflowException__); + } + var buffer = new Node.Buffer(length); + this.b.slice(this._position, this._position + length).copy(buffer); + this._position += length; + return buffer; + }, + getArrayAt: function(position, length) + { + if(position + length > this._limit) + { + throw new Error(__BufferUnderflowException__); + } + var buffer = new Node.Buffer(length); + length = length === undefined ? (this.b.length - position) : length; + this.b.slice(position, position + length).copy(buffer); + return buffer; + }, + getShort: function() + { + var v; + if(this._limit - this._position < 2) + { + throw new Error(__BufferUnderflowException__); + } + v = this.b.readInt16LE(this._position, true); + this._position += 2; + return v; + }, + getInt: function() + { + var v; + if(this._limit - this._position < 4) + { + throw new Error(__BufferUnderflowException__); + } + v = this.b.readInt32LE(this._position, true); + this._position += 4; + return v; + }, + getFloat: function() + { + if(this._limit - this._position < 4) + { + throw new Error(__BufferUnderflowException__); + } + var v = this.b.readFloatLE(this._position, true); + this._position += 4; + return v; + }, + getDouble: function() + { + if(this._limit - this._position < 8) + { + throw new Error(__BufferUnderflowException__); + } + var v = this.b.readDoubleLE(this._position, true); + this._position += 8; + return v; + }, + getLong: function() + { + if(this._limit - this._position < 8) + { + throw new Error(__BufferUnderflowException__); + } + var v = new Long(); + v.low = this.b.readUInt32LE(this._position, true); + this._position += 4; + v.high = this.b.readUInt32LE(this._position, true); + this._position += 4; + return v; + }, + getString: function(length) + { + if(this._position + length > this._limit) + { + throw new Error(__BufferUnderflowException__); + } + var s =this.b.toString("utf8", this._position, this._position + length); + this._position += length; + return s; + } + }); + + var prototype = Buffer.prototype; + + Object.defineProperty(prototype, "position", { + get: function() { return this._position; }, + set: function(position){ + if(position >= 0 && position <= this._limit) + { + this._position = position; + } + } + }); + + Object.defineProperty(prototype, "limit", { + get: function() { return this._limit; }, + set: function(limit){ + if(limit <= this.capacity) + { + this._limit = limit; + if(this._position > limit) + { + this._position = limit; + } + } + } + }); + + Object.defineProperty(prototype, "capacity", { + get: function() { return this.b === null ? 0 : this.b.length; } + }); + + Object.defineProperty(prototype, "remaining", { + get: function() { return this._limit - this._position; } + }); + + // + // Create a native buffer from an array of bytes. + // + Buffer.createNative = function(data) + { + if(data === undefined) + { + return new Node.Buffer(0); + } + else + { + return new Node.Buffer(data); + } + }; + + Ice.Buffer = Buffer; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Class.js b/js/src/Ice/Class.js new file mode 100644 index 00000000000..1e1778fb71f --- /dev/null +++ b/js/src/Ice/Class.js @@ -0,0 +1,58 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + var Ice = global.Ice || {}; + + var Class = function() + { + var base; + var desc; + var constructor; + + if(arguments.length == 1) + { + desc = arguments[0]; + } + else if(arguments.length == 2) + { + base = arguments[0]; + desc = arguments[1]; + } + + if(desc !== undefined) + { + constructor = desc.__init__; + if(constructor) + { + delete desc.__init__; + } + } + + var o = constructor || function(){}; + + if(base !== undefined) + { + o.prototype = new base(); + o.prototype.constructor = o; + } + + if(desc !== undefined) + { + for(var key in desc) + { + o.prototype[key] = desc[key]; + } + } + return o; + }; + + Ice.Class = Class; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Communicator.js b/js/src/Ice/Communicator.js new file mode 100644 index 00000000000..b2427221eb1 --- /dev/null +++ b/js/src/Ice/Communicator.js @@ -0,0 +1,166 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Instance"); + require("Ice/Promise"); + require("Ice/UUID"); + require("Ice/AsyncResultBase"); + + var Ice = global.Ice || {}; + + var Instance = Ice.Instance; + var Promise = Ice.Promise; + var UUID = Ice.UUID; + + // + // Ice.Communicator + // + var Communicator = Ice.Class({ + __init__: function(initData) + { + this._instance = new Instance(initData); + }, + // + // Certain initialization tasks need to be completed after the + // constructor. + // + finishSetup: function(promise) + { + this._instance.finishSetup(this, promise); + }, + destroy: function() + { + return this._instance.destroy(); + }, + shutdown: function() + { + this._instance.objectAdapterFactory().shutdown(); + }, + waitForShutdown: function() + { + return this._instance.objectAdapterFactory().waitForShutdown(); + }, + isShutdown: function() + { + return this._instance.objectAdapterFactory().isShutdown(); + }, + stringToProxy: function(s) + { + return this._instance.proxyFactory().stringToProxy(s); + }, + proxyToString: function(proxy) + { + return this._instance.proxyFactory().proxyToString(proxy); + }, + propertyToProxy: function(s) + { + return this._instance.proxyFactory().propertyToProxy(s); + }, + proxyToProperty: function(proxy, prefix) + { + return this._instance.proxyFactory().proxyToProperty(proxy, prefix); + }, + stringToIdentity: function(s) + { + return this._instance.stringToIdentity(s); + }, + identityToString: function(ident) + { + return this._instance.identityToString(ident); + }, + createObjectAdapter: function(name) + { + var promise = new Ice.AsyncResultBase(this, "createObjectAdapter", this, null, null); + this._instance.objectAdapterFactory().createObjectAdapter(name, null, promise); + return promise; + }, + createObjectAdapterWithEndpoints: function(name, endpoints) + { + if(name.length === 0) + { + name = UUID.generateUUID(); + } + + this.getProperties().setProperty(name + ".Endpoints", endpoints); + var promise = new Ice.AsyncResultBase(this, "createObjectAdapterWithEndpoints", this, null, null); + this._instance.objectAdapterFactory().createObjectAdapter(name, null, promise); + return promise; + }, + createObjectAdapterWithRouter: function(name, router) + { + if(name.length === 0) + { + name = UUID.generateUUID(); + } + + var promise = new Ice.AsyncResultBase(this, "createObjectAdapterWithRouter", this, null, null); + + // + // We set the proxy properties here, although we still use the proxy supplied. + // + var properties = this.proxyToProperty(router, name + ".Router"); + for(var e = properties.entries; e !== null; e = e.next) + { + this.getProperties().setProperty(e.key, e.value); + } + + this._instance.objectAdapterFactory().createObjectAdapter(name, router, promise); + return promise; + }, + addObjectFactory: function(factory, id) + { + this._instance.servantFactoryManager().add(factory, id); + }, + findObjectFactory: function(id) + { + return this._instance.servantFactoryManager().find(id); + }, + getImplicitContext: function() + { + return this._instance.getImplicitContext(); + }, + getProperties: function() + { + return this._instance.initializationData().properties; + }, + getLogger: function() + { + return this._instance.initializationData().logger; + }, + getDefaultRouter: function() + { + return this._instance.referenceFactory().getDefaultRouter(); + }, + setDefaultRouter: function(router) + { + this._instance.setDefaultRouter(router); + }, + getDefaultLocator: function() + { + return this._instance.referenceFactory().getDefaultLocator(); + }, + setDefaultLocator: function(locator) + { + this._instance.setDefaultLocator(locator); + }, + flushBatchRequests: function() + { + return this._instance.outgoingConnectionFactory().flushAsyncBatchRequests(); + } + }); + + Object.defineProperty(Communicator.prototype, "instance", { + get: function() { return this._instance; } + }); + + Ice.Communicator = Communicator; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/CompactIdRegistry.js b/js/src/Ice/CompactIdRegistry.js new file mode 100644 index 00000000000..b3f46caadf3 --- /dev/null +++ b/js/src/Ice/CompactIdRegistry.js @@ -0,0 +1,15 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/HashMap"); + var Ice = global.Ice || {}; + Ice.CompactIdRegistry = new Ice.HashMap(); + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ConnectRequestHandler.js b/js/src/Ice/ConnectRequestHandler.js new file mode 100644 index 00000000000..c6053f3945a --- /dev/null +++ b/js/src/Ice/ConnectRequestHandler.js @@ -0,0 +1,429 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/AsyncResult"); + require("Ice/AsyncStatus"); + require("Ice/BasicStream"); + require("Ice/BatchOutgoingAsync"); + require("Ice/ConnectionRequestHandler"); + require("Ice/Debug"); + require("Ice/ExUtil"); + require("Ice/LocalExceptionWrapper"); + require("Ice/OutgoingAsync"); + require("Ice/Protocol"); + require("Ice/ReferenceMode"); + require("Ice/Exception"); + require("Ice/Promise"); + + var Ice = global.Ice || {}; + + var AsyncResult = Ice.AsyncResult; + var AsyncStatus = Ice.AsyncStatus; + var BasicStream = Ice.BasicStream; + var BatchOutgoingAsync = Ice.BatchOutgoingAsync; + var ConnectionRequestHandler = Ice.ConnectionRequestHandler; + var Debug = Ice.Debug; + var ExUtil = Ice.ExUtil; + var LocalExceptionWrapper = Ice.LocalExceptionWrapper; + var OutgoingAsync = Ice.OutgoingAsync; + var Protocol = Ice.Protocol; + var ReferenceMode = Ice.ReferenceMode; + var LocalException = Ice.LocalException; + var Promise = Ice.Promise; + + var ConnectRequestHandler = Ice.Class({ + __init__: function(ref, proxy) + { + this._reference = ref; + this._response = ref.getMode() === ReferenceMode.ModeTwoway; + this._proxy = proxy; + this._batchAutoFlush = ref.getInstance().initializationData().properties.getPropertyAsIntWithDefault( + "Ice.BatchAutoFlush", 1) > 0 ? true : false; + this._initialized = false; + this._flushing = false; + this._batchRequestInProgress = false; + this._batchRequestsSize = Protocol.requestBatchHdr.length; + this._batchStream = + new BasicStream(ref.getInstance(), Protocol.currentProtocolEncoding, this._batchAutoFlush); + this._updateRequestHandler = false; + + this._connection = null; + this._compress = false; + this._exception = null; + this._requests = []; + this._updateRequestHandler = false; + this._pendingPromises = []; + }, + connect: function() + { + var self = this; + this._reference.getConnection().then( + function(connection, compress) + { + self.setConnection(connection, compress); + }).exception( + function(ex) + { + self.setException(ex); + }); + + if(this.initialized()) + { + Debug.assert(this._connection !== null); + return new ConnectionRequestHandler(this._reference, this._connection, this._compress); + } + else + { + // The proxy request handler will be updated when the connection is set. + this._updateRequestHandler = true; + return this; + } + }, + prepareBatchRequest: function(os) + { + if(!this.initialized()) + { + this._batchRequestInProgress = true; + this._batchStream.swap(os); + return; + } + + this._connection.prepareBatchRequest(os); + }, + finishBatchRequest: function(os) + { + if(!this.initialized()) + { + Debug.assert(this._batchRequestInProgress); + this._batchRequestInProgress = false; + + this._batchStream.swap(os); + + if(!this._batchAutoFlush && + this._batchStream.size + this._batchRequestsSize > this._reference.getInstance().messageSizeMax()) + { + ExUtil.throwMemoryLimitException(this._batchStream.size + this._batchRequestsSize, + this._reference.getInstance().messageSizeMax()); + } + + this._requests.push(new Request(this._batchStream)); + return; + } + this._connection.finishBatchRequest(os, this._compress); + }, + abortBatchRequest: function() + { + if(!this.initialized()) + { + Debug.assert(this._batchRequestInProgress); + this._batchRequestInProgress = false; + + var dummy = new BasicStream(this._reference.getInstance(), Protocol.currentProtocolEncoding, + this._batchAutoFlush); + this._batchStream.swap(dummy); + this._batchRequestsSize = Protocol.requestBatchHdr.length; + + return; + } + this._connection.abortBatchRequest(); + }, + sendAsyncRequest: function(out) + { + if(!this.initialized()) + { + this._requests.push(new Request(out)); + return AsyncStatus.Queued; + } + return this._connection.sendAsyncRequest(out, this._compress, this._response); + }, + flushAsyncBatchRequests: function(out) + { + if(!this.initialized()) + { + this._requests.push(new Request(out)); + return AsyncStatus.Queued; + } + return this._connection.flushAsyncBatchRequests(out); + }, + getReference: function() + { + return this._reference; + }, + getConnection: function() + { + if(this._exception !== null) + { + throw this._exception; + } + else + { + return this._connection; + } + }, + onConnection: function(r) + { + // + // Called by ObjectPrx.ice_getConnection + // + + if(this._exception !== null) + { + r.__exception(this._exception); + } + else if(this._connection !== null) + { + Debug.assert(this._initialized); + r.succeed(this._connection, r); + } + else + { + this._pendingPromises.push(r); + } + }, + // + // Implementation of Reference_GetConnectionCallback + // + + setConnection: function(connection, compress) + { + Debug.assert(this._exception === null && this._connection === null); + Debug.assert(this._updateRequestHandler || this._requests.length === 0); + + this._connection = connection; + this._compress = compress; + + // + // If this proxy is for a non-local object, and we are using a router, then + // add this proxy to the router info object. + // + var ri = this._reference.getRouterInfo(); + if(ri !== null) + { + var self = this; + var promise = ri.addProxy(this._proxy).then( + function() + { + // + // The proxy was added to the router info, we're now ready to send the + // queued requests. + // + self.flushRequests(); + }).exception( + function(ex) + { + self.setException(ex); + }); + + if(!promise.completed()) + { + return; // The request handler will be initialized once addProxy completes. + } + } + + // + // We can now send the queued requests. + // + this.flushRequests(); + }, + setException: function(ex) + { + Debug.assert(!this._initialized && this._exception === null); + Debug.assert(this._updateRequestHandler || this._requests.length === 0); + + this._exception = ex; + this._proxy = null; // Break cyclic reference count. + + // + // If some requests were queued, we notify them of the failure. + // + if(this._requests.length > 0) + { + this.flushRequestsWithException(ex); + } + + for(var i = 0; i < this._pendingPromises.length; ++i) + { + this._pendingPromises[i].fail(ex); + } + this._pendingPromises = []; + }, + initialized: function() + { + if(this._initialized) + { + Debug.assert(this._connection !== null); + return true; + } + else + { + if(this._exception !== null) + { + throw this._exception; + } + else + { + return this._initialized; + } + } + }, + flushRequests: function() + { + Debug.assert(this._connection !== null && !this._initialized); + + // + // We set the _flushing flag to true to prevent any additional queuing. Callers + // might block for a little while as the queued requests are being sent but this + // shouldn't be an issue as the request sends are non-blocking. + // + this._flushing = true; + + try + { + while(this._requests.length > 0) + { + var request = this._requests[0]; + if(request.out !== null) + { + this._connection.sendAsyncRequest(request.out, this._compress, this._response); + } + else if(request.batchOut !== null) + { + this._connection.flushAsyncBatchRequests(request.batchOut); + } + else + { + var os = new BasicStream(request.os.instance, Protocol.currentProtocolEncoding); + this._connection.prepareBatchRequest(os); + try + { + request.os.pos = 0; + os.writeBlob(request.os.readBlob(request.os.size)); + } + catch(ex) + { + this._connection.abortBatchRequest(); + throw ex; + } + this._connection.finishBatchRequest(os, this._compress); + } + this._requests.shift(); + } + } + catch(ex) + { + if(ex instanceof LocalExceptionWrapper) + { + Debug.assert(this._exception === null && this._requests.length > 0); + this._exception = ex.inner; + this.flushRequestsWithExceptionWrapper(ex); + } + else if(ex instanceof LocalException) + { + Debug.assert(this._exception === null && this._requests.length > 0); + this._exception = ex; + this.flushRequestsWithException(ex); + } + else + { + throw ex; + } + } + + // + // We've finished sending the queued requests and the request handler now send + // the requests over the connection directly. It's time to substitute the + // request handler of the proxy with the more efficient connection request + // handler which does not have any synchronization. This also breaks the cyclic + // reference count with the proxy. + // + // NOTE: _updateRequestHandler is immutable once _flushing = true + // + if(this._updateRequestHandler && this._exception === null) + { + this._proxy.__setRequestHandler( + new ConnectionRequestHandler(this._reference, this._connection, this._compress)); + } + + Debug.assert(!this._initialized); + if(this._exception === null) + { + this._initialized = true; + this._flushing = false; + } + this._proxy = null; // Break cyclic reference count. + + var p; + for(var i = 0; i < this._pendingPromises.length; ++i) + { + p = this._pendingPromises[i]; + p.succeed(this._connection, p); + } + this._pendingPromises = []; + }, + flushRequestsWithException: function(ex) + { + for(var i = 0; i < this._requests.length; ++i) + { + var request = this._requests[i]; + if(request.out !== null) + { + request.out.__finishedEx(ex, false); + } + else if(request.batchOut !== null) + { + request.batchOut.__finishedEx(ex, false); + } + } + this._requests = []; + }, + flushRequestsWithExceptionWrapper: function(ex) + { + for(var i = 0; i < this._requests.length; ++i) + { + var request = this._requests[i]; + if(request.out !== null) + { + request.out.__finishedWrapper(ex); + } + else if(request.batchOut !== null) + { + request.batchOut.__finishedEx(ex.inner, false); + } + } + this._requests = []; + } + }); + + Ice.ConnectRequestHandler = ConnectRequestHandler; + global.Ice = Ice; + + var Request = function(arg) + { + this.os = null; + this.out = null; + this.batchOut = null; + + if(arg instanceof BasicStream) + { + this.os = new BasicStream(arg.instance, Protocol.currentProtocolEncoding); + this.os.swap(arg); + } + else if(arg instanceof OutgoingAsync) + { + this.out = arg; + } + else + { + Debug.assert(arg instanceof BatchOutgoingAsync); + this.batchOut = arg; + } + }; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ConnectionBatchOutgoingAsync.js b/js/src/Ice/ConnectionBatchOutgoingAsync.js new file mode 100644 index 00000000000..f4f4d801544 --- /dev/null +++ b/js/src/Ice/ConnectionBatchOutgoingAsync.js @@ -0,0 +1,30 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_FOR_ACTIONSCRIPT_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/BatchOutgoingAsync"); + + var Ice = global.Ice || {}; + + var BatchOutgoingAsync = Ice.BatchOutgoingAsync; + + Ice.ConnectionBatchOutgoingAsync = Ice.Class(BatchOutgoingAsync, { + __init__: function(con, communicator, operation) + { + BatchOutgoingAsync.call(this, communicator, operation); + this._connection = con; + }, + __send: function() + { + this._connection.flushAsyncBatchRequests(this); + } + }); + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ConnectionI.js b/js/src/Ice/ConnectionI.js new file mode 100644 index 00000000000..f08d9474bd3 --- /dev/null +++ b/js/src/Ice/ConnectionI.js @@ -0,0 +1,2030 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/AsyncStatus"); + require("Ice/AsyncResultBase"); + require("Ice/BasicStream"); + require("Ice/ConnectionBatchOutgoingAsync"); + require("Ice/Debug"); + require("Ice/ExUtil"); + require("Ice/HashMap"); + require("Ice/IncomingAsync"); + require("Ice/LocalExceptionWrapper"); + require("Ice/Promise"); + require("Ice/Protocol"); + require("Ice/SocketOperation"); + require("Ice/Timer"); + require("Ice/TraceUtil"); + require("Ice/Version"); + require("Ice/Exception"); + require("Ice/LocalException"); + + var Ice = global.Ice || {}; + + var AsyncStatus = Ice.AsyncStatus; + var AsyncResultBase = Ice.AsyncResultBase; + var BasicStream = Ice.BasicStream; + var ConnectionBatchOutgoingAsync = Ice.ConnectionBatchOutgoingAsync; + var Debug = Ice.Debug; + var ExUtil = Ice.ExUtil; + var HashMap = Ice.HashMap; + var IncomingAsync = Ice.IncomingAsync; + var LocalExceptionWrapper = Ice.LocalExceptionWrapper; + var Promise = Ice.Promise; + var Protocol = Ice.Protocol; + var SocketOperation = Ice.SocketOperation; + var Timer = Ice.Timer; + var TraceUtil = Ice.TraceUtil; + var ProtocolVersion = Ice.ProtocolVersion; + var EncodingVersion = Ice.EncodingVersion; + + var StateNotInitialized = 0; + var StateNotValidated = 1; + var StateActive = 2; + var StateHolding = 3; + var StateClosing = 4; + var StateClosed = 5; + var StateFinished = 6; + + var MessageInfo = function(instance) + { + this.stream = new BasicStream(instance, Protocol.currentProtocolEncoding, false); + + this.invokeNum = 0; + this.requestId = 0; + this.compress = false; + this.servantManager = null; + this.adapter = null; + this.outAsync = null; + }; + + var Class = Ice.Class; + + var ConnectionI = Class({ + __init__: function(communicator, instance, reaper, transceiver, endpoint, incoming, adapter) + { + this._communicator = communicator; + this._instance = instance; + this._reaper = reaper; + this._transceiver = transceiver; + this._desc = transceiver.toString(); + this._type = transceiver.type(); + this._endpoint = endpoint; + this._incoming = incoming; + this._adapter = adapter; + var initData = instance.initializationData(); + this._logger = initData.logger; // Cached for better performance. + this._traceLevels = instance.traceLevels(); // Cached for better performance. + this._timer = instance.timer(); + this._writeTimeoutId = 0; + this._writeTimeoutScheduled = false; + this._readTimeoutId = 0; + this._readTimeoutScheduled = false; + + this._hasMoreData = { value: false }; + + this._warn = initData.properties.getPropertyAsInt("Ice.Warn.Connections") > 0; + this._warnUdp = instance.initializationData().properties.getPropertyAsInt("Ice.Warn.Datagrams") > 0; + this._acmAbsoluteTimeoutMillis = 0; + + this._nextRequestId = 1; + this._batchAutoFlush = initData.properties.getPropertyAsIntWithDefault("Ice.BatchAutoFlush", 1) > 0 ? true : false; + this._batchStream = new BasicStream(instance, Protocol.currentProtocolEncoding, this._batchAutoFlush); + this._batchStreamInUse = false; + this._batchRequestNum = 0; + this._batchRequestCompress = false; + this._batchMarker = 0; + + this._sendStreams = []; + + this._readStream = new BasicStream(instance, Protocol.currentProtocolEncoding); + this._readHeader = false; + this._writeStream = new BasicStream(instance, Protocol.currentProtocolEncoding); + + this._readStreamPos = -1; + this._writeStreamPos = -1; + + this._dispatchCount = 0; + + this._state = StateNotInitialized; + this._shutdownInitiated = false; + this._validated = false; + + this._readProtocol = new ProtocolVersion(); + this._readProtocolEncoding = new EncodingVersion(); + + this._asyncRequests = new HashMap(); // Map<int, OutgoingAsync> + + this._exception = null; + + this._startPromise = null; + this._closePromises = []; + this._holdPromises = []; + this._finishedPromises = []; + + if(this._adapter !== null) + { + this._servantManager = this._adapter.getServantManager(); + } + else + { + this._servantManager = null; + } + + if(this._endpoint.datagram()) + { + this._acmTimeout = 0; + } + else + { + if(this._adapter !== null) + { + this._acmTimeout = this._adapter.getACM(); + } + else + { + this._acmTimeout = this._instance.clientACM(); + } + } + }, + start: function() + { + Debug.assert(this._startPromise === null); + + try + { + // The connection might already be closed if the communicator was destroyed. + if(this._state >= StateClosed) + { + Debug.assert(this._exception !== null); + return new Promise().fail(this._exception); + } + + this._startPromise = new Promise(); + var self = this; + this._transceiver.setCallbacks( + function() { self.message(SocketOperation.Write); }, // connected callback + function() { self.message(SocketOperation.Read); }, // read callback + function() { self.message(SocketOperation.Write); } // write callback + ); + this.initialize(); + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.exception(ex); + } + return new Promise().fail(ex); + } + + return this._startPromise; + }, + activate: function() + { + if(this._state <= StateNotValidated) + { + return; + } + + if(this._acmTimeout > 0) + { + this._acmAbsoluteTimeoutMillis = Date.now() + this._acmTimeout * 1000; + } + + this.setState(StateActive); + }, + hold: function() + { + if(this._state <= StateNotValidated) + { + return; + } + + this.setState(StateHolding); + }, + destroy: function(reason) + { + switch(reason) + { + case ConnectionI.ObjectAdapterDeactivated: + { + this.setStateEx(StateClosing, new Ice.ObjectAdapterDeactivatedException()); + break; + } + + case ConnectionI.CommunicatorDestroyed: + { + this.setStateEx(StateClosing, new Ice.CommunicatorDestroyedException()); + break; + } + } + }, + close: function(force) + { + var __r = new AsyncResultBase(this._communicator, "close", this, null, null); + + if(force) + { + this.setStateEx(StateClosed, new Ice.ForcedCloseConnectionException()); + __r.succeed(__r); + } + else + { + // + // If we do a graceful shutdown, then we wait until all + // outstanding requests have been completed. Otherwise, + // the CloseConnectionException will cause all outstanding + // requests to be retried, regardless of whether the + // server has processed them or not. + // + this._closePromises.push(__r); + this.checkClose(); + } + + return __r; + }, + checkClose: function() + { + // + // If close(false) has been called, then we need to check if all + // requests have completed and we can transition to StateClosing. + // We also complete outstanding promises. + // + if(this._asyncRequests.size === 0 && this._closePromises.length > 0) + { + this.setStateEx(StateClosing, new Ice.CloseConnectionException()); + for(var i = 0; i < this._closePromises.length; ++i) + { + this._closePromises[i].succeed(this._closePromises[i]); + } + this._closePromises = []; + } + }, + isActiveOrHolding: function() + { + return this._state > StateNotValidated && this._state < StateClosing; + }, + isFinished: function() + { + if(this._state !== StateFinished || this._dispatchCount !== 0) + { + return false; + } + + Debug.assert(this._state === StateFinished); + return true; + }, + throwException: function() + { + if(this._exception !== null) + { + Debug.assert(this._state >= StateClosing); + throw this._exception; + } + }, + waitUntilHolding: function() + { + var promise = new Promise(); + this._holdPromises.push(promise); + this.checkState(); + return promise; + }, + waitUntilFinished: function() + { + var promise = new Promise(); + this._finishedPromises.push(promise); + this.checkState(); + return promise; + }, + monitor: function(now) + { + if(this._state !== StateActive) + { + return; + } + + // + // Active connection management for idle connections. + // + if(this._acmTimeout <= 0 || + this._asyncRequests.size > 0 || this._dispatchCount > 0 || + this._readStream.size > Protocol.headerSize || !this._writeStream.isEmpty() || + !this._batchStream.isEmpty()) + { + return; + } + + if(now >= this._acmAbsoluteTimeoutMillis) + { + this.setStateEx(StateClosing, new Ice.ConnectionTimeoutException()); + } + }, + sendAsyncRequest: function(out, compress, response) + { + var requestId = 0; + var os = out.__os(); + + if(this._exception !== null) + { + // + // If the connection is closed before we even have a chance + // to send our request, we always try to send the request + // again. + // + throw new LocalExceptionWrapper(this._exception, true); + } + + Debug.assert(this._state > StateNotValidated); + Debug.assert(this._state < StateClosing); + + // + // Ensure the message isn't bigger than what we can send with the + // transport. + // + this._transceiver.checkSendSize(os, this._instance.messageSizeMax()); + + if(response) + { + // + // Create a new unique request ID. + // + requestId = this._nextRequestId++; + if(requestId <= 0) + { + this._nextRequestId = 1; + requestId = this._nextRequestId++; + } + + // + // Fill in the request ID. + // + os.pos = Protocol.headerSize; + os.writeInt(requestId); + } + + var status; + try + { + status = this.sendMessage(OutgoingMessage.create(out, out.__os(), compress, requestId)); + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.setStateEx(StateClosed, ex); + Debug.assert(this._exception !== null); + throw this._exception; + } + else + { + throw ex; + } + } + + if(response) + { + // + // Add to the async requests map. + // + this._asyncRequests.set(requestId, out); + } + + return status; + }, + prepareBatchRequest: function(os) + { + if(this._exception !== null) + { + // + // If there were no batch requests queued when the connection failed, we can safely + // retry with a new connection. Otherwise, we must throw to notify the caller that + // some previous batch requests were not sent. + // + if(this._batchStream.isEmpty()) + { + throw new LocalExceptionWrapper(this._exception, true); + } + else + { + throw this._exception; + } + } + + Debug.assert(this._state > StateNotValidated); + Debug.assert(this._state < StateClosing); + + if(this._batchStream.isEmpty()) + { + try + { + this._batchStream.writeBlob(Protocol.requestBatchHdr); + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.setStateEx(StateClosed, ex); + } + throw ex; + } + } + + this._batchStreamInUse = true; + this._batchMarker = this._batchStream.size; + this._batchStream.swap(os); + + // + // The batch stream now belongs to the caller, until + // finishBatchRequest() or abortBatchRequest() is called. + // + }, + finishBatchRequest: function(os, compress) + { + try + { + // + // Get the batch stream back. + // + this._batchStream.swap(os); + + if(this._exception !== null) + { + throw this._exception; + } + + var flush = false; + if(this._batchAutoFlush) + { + // + // Throw memory limit exception if the first message added causes us to go over + // limit. Otherwise put aside the marshalled message that caused limit to be + // exceeded and rollback stream to the marker. + try + { + this._transceiver.checkSendSize(this._batchStream.buffer, this._instance.messageSizeMax()); + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + if(this._batchRequestNum > 0) + { + flush = true; + } + else + { + throw ex; + } + } + else + { + throw ex; + } + } + } + + if(flush) + { + // + // Temporarily save the last request. + // + var sz = this._batchStream.size - this._batchMarker; + this._batchStream.pos = this._batchMarker; + var lastRequest = this._batchStream.readBlob(sz); + this._batchStream.resize(this._batchMarker, false); + + try + { + // + // Fill in the number of requests in the batch. + // + this._batchStream.pos = Protocol.headerSize; + this._batchStream.writeInt(this._batchRequestNum); + + this.sendMessage(OutgoingMessage.createForStream(this._batchStream, this._batchRequestCompress, + true)); + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.setStateEx(StateClosed, ex); + Debug.assert(this._exception !== null); + throw this._exception; + } + else + { + throw ex; + } + } + + // + // Reset the batch stream. + // + this._batchStream = + new BasicStream(this._instance, Protocol.currentProtocolEncoding, this._batchAutoFlush); + this._batchRequestNum = 0; + this._batchRequestCompress = false; + this._batchMarker = 0; + + // + // Check again if the last request doesn't exceed the maximum message size. + // + if(Protocol.requestBatchHdr.length + lastRequest.length > this._instance.messageSizeMax()) + { + ExUtil.throwMemoryLimitException( + Protocol.requestBatchHdr.length + lastRequest.length, + this._instance.messageSizeMax()); + } + + // + // Start a new batch with the last message that caused us to go over the limit. + // + this._batchStream.writeBlob(Protocol.requestBatchHdr); + this._batchStream.writeBlob(lastRequest); + } + + // + // Increment the number of requests in the batch. + // + ++this._batchRequestNum; + + // + // We compress the whole batch if there is at least one compressed + // message. + // + if(compress) + { + this._batchRequestCompress = true; + } + + // + // The batch stream is not in use anymore. + // + Debug.assert(this._batchStreamInUse); + this._batchStreamInUse = false; + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.abortBatchRequest(); + } + throw ex; + } + }, + abortBatchRequest: function() + { + this._batchStream = new BasicStream(this._instance, Protocol.currentProtocolEncoding, this._batchAutoFlush); + this._batchRequestNum = 0; + this._batchRequestCompress = false; + this._batchMarker = 0; + + Debug.assert(this._batchStreamInUse); + this._batchStreamInUse = false; + }, + flushBatchRequests: function() + { + var result = new ConnectionBatchOutgoingAsync(this, this._communicator, "flushBatchRequests"); + try + { + result.__send(); + } + catch(ex) + { + result.__exception(ex); + } + return result; + }, + flushAsyncBatchRequests: function(outAsync) + { + if(this._exception !== null) + { + throw this._exception; + } + + var status; + if(this._batchRequestNum === 0) + { + outAsync.__sent(this); + return AsyncStatus.Sent; + } + + // + // Fill in the number of requests in the batch. + // + this._batchStream.pos = Protocol.headerSize; + this._batchStream.writeInt(this._batchRequestNum); + + this._batchStream.swap(outAsync.__os()); + + try + { + status = this.sendMessage(OutgoingMessage.create(outAsync, outAsync.__os(), this._batchRequestCompress, + 0)); + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.setStateEx(StateClosed, ex); + Debug.assert(this._exception !== null); + throw this._exception; + } + else + { + throw ex; + } + } + + // + // Reset the batch stream. + // + this._batchStream = new BasicStream(this._instance, Protocol.currentProtocolEncoding, this._batchAutoFlush); + this._batchRequestNum = 0; + this._batchRequestCompress = false; + this._batchMarker = 0; + return status; + }, + sendResponse: function(os, compressFlag) + { + Debug.assert(this._state > StateNotValidated); + + try + { + if(--this._dispatchCount === 0) + { + if(this._state === StateFinished) + { + this._reaper.add(this); + } + this.checkState(); + } + + if(this._state >= StateClosed) + { + Debug.assert(this._exception !== null); + throw this._exception; + } + + this.sendMessage(OutgoingMessage.createForStream(os, compressFlag !== 0, true)); + + if(this._state === StateClosing && this._dispatchCount === 0) + { + this.initiateShutdown(); + } + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.setStateEx(StateClosed, ex); + } + else + { + throw ex; + } + } + }, + sendNoResponse: function() + { + Debug.assert(this._state > StateNotValidated); + try + { + if(--this._dispatchCount === 0) + { + if(this._state === StateFinished) + { + this._reaper.add(this); + } + this.checkState(); + } + + if(this._state >= StateClosed) + { + Debug.assert(this._exception !== null); + throw this._exception; + } + + if(this._state === StateClosing && this._dispatchCount === 0) + { + this.initiateShutdown(); + } + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.setStateEx(StateClosed, ex); + } + else + { + throw ex; + } + } + }, + endpoint: function() + { + return this._endpoint; + }, + setAdapter: function(adapter) + { + if(this._state <= StateNotValidated || this._state >= StateClosing) + { + return; + } + Debug.assert(this._state < StateClosing); + + this._adapter = adapter; + + if(this._adapter !== null) + { + this._servantManager = this._adapter.getServantManager(); + if(this._servantManager === null) + { + this._adapter = null; + } + } + else + { + this._servantManager = null; + } + }, + getAdapter: function() + { + return this._adapter; + }, + getEndpoint: function() + { + return this._endpoint; + }, + createProxy: function(ident) + { + // + // Create a reference and return a reverse proxy for this + // reference. + // + return this._instance.proxyFactory().referenceToProxy( + this._instance.referenceFactory().createFixed(ident, this)); + }, + message: function(operation) + { + if(this._state >= StateClosed) + { + return; + } + + this.unscheduleTimeout(operation); + // + // Keep reading until no more data is available. + // + this._hasMoreData.value = (operation & SocketOperation.Read) !== 0; + do + { + var info = null; + + try + { + if((operation & SocketOperation.Write) !== 0 && this._writeStream.buffer.remaining > 0) + { + if(!this._transceiver.write(this._writeStream.buffer)) + { + Debug.assert(!this._writeStream.isEmpty()); + this.scheduleTimeout(SocketOperation.Write, this._endpoint.timeout()); + return; + } + Debug.assert(this._writeStream.buffer.remaining === 0); + } + if((operation & SocketOperation.Read) !== 0 && !this._readStream.isEmpty()) + { + if(this._readHeader) // Read header if necessary. + { + if(!this._transceiver.read(this._readStream.buffer, this._hasMoreData)) + { + // + // We didn't get enough data to complete the header. + // + return; + } + + Debug.assert(this._readStream.buffer.remaining === 0); + this._readHeader = false; + + var pos = this._readStream.pos; + if(pos < Protocol.headerSize) + { + // + // This situation is possible for small UDP packets. + // + throw new Ice.IllegalMessageSizeException(); + } + + this._readStream.pos = 0; + var magic0 = this._readStream.readByte(); + var magic1 = this._readStream.readByte(); + var magic2 = this._readStream.readByte(); + var magic3 = this._readStream.readByte(); + if(magic0 !== Protocol.magic[0] || magic1 !== Protocol.magic[1] || + magic2 !== Protocol.magic[2] || magic3 !== Protocol.magic[3]) + { + var bme = new Ice.BadMagicException(); + bme.badMagic = Ice.Buffer.createNative([magic0, magic1, magic2, magic3]); + throw bme; + } + + this._readProtocol.__read(this._readStream); + Protocol.checkSupportedProtocol(this._readProtocol); + + this._readProtocolEncoding.__read(this._readStream); + Protocol.checkSupportedProtocolEncoding(this._readProtocolEncoding); + + this._readStream.readByte(); // messageType + this._readStream.readByte(); // compress + var size = this._readStream.readInt(); + if(size < Protocol.headerSize) + { + throw new Ice.IllegalMessageSizeException(); + } + if(size > this._instance.messageSizeMax()) + { + ExUtil.throwMemoryLimitException(size, this._instance.messageSizeMax()); + } + if(size > this._readStream.size) + { + this._readStream.resize(size); + } + this._readStream.pos = pos; + } + + if(this._readStream.pos != this._readStream.size) + { + if(this._endpoint.datagram()) + { + throw new Ice.DatagramLimitException(); // The message was truncated. + } + else + { + if(!this._transceiver.read(this._readStream.buffer, this._hasMoreData)) + { + Debug.assert(!this._readStream.isEmpty()); + this.scheduleTimeout(SocketOperation.Read, this._endpoint.timeout()); + return; + } + Debug.assert(this._readStream.buffer.remaining === 0); + } + } + } + + if(this._state <= StateNotValidated) + { + if(this._state === StateNotInitialized && !this.initialize()) + { + return; + } + + if(this._state <= StateNotValidated && !this.validate()) + { + return; + } + + this._transceiver.unregister(); + + // + // We start out in holding state. + // + this.setState(StateHolding); + } + else + { + Debug.assert(this._state <= StateClosing); + + // + // We parse messages first, if we receive a close + // connection message we won't send more messages. + // + if((operation & SocketOperation.Read) !== 0) + { + info = this.parseMessage(); + } + + if((operation & SocketOperation.Write) !== 0) + { + this.sendNextMessage(); + } + + // + // We increment the dispatch count to prevent the + // communicator destruction during the callback. + // + if(info !== null && info.outAsync !== null) + { + ++this._dispatchCount; + } + } + } + catch(ex) + { + if(ex instanceof Ice.DatagramLimitException) // Expected. + { + if(this._warnUdp) + { + this._logger.warning("maximum datagram size of " + this._readStream.pos + " exceeded"); + } + this._readStream.resize(Protocol.headerSize); + this._readStream.pos = 0; + this._readHeader = true; + return; + } + else if(ex instanceof Ice.SocketException) + { + this.setStateEx(StateClosed, ex); + return; + } + else if(ex instanceof Ice.LocalException) + { + if(this._endpoint.datagram()) + { + if(this._warn) + { + this._logger.warning("datagram connection exception:\n" + ex + '\n' + this._desc); + } + this._readStream.resize(Protocol.headerSize); + this._readStream.pos = 0; + this._readHeader = true; + } + else + { + this.setStateEx(StateClosed, ex); + } + return; + } + else + { + throw ex; + } + } + + if(this._acmTimeout > 0) + { + this._acmAbsoluteTimeoutMillis = Date.now() + this._acmTimeout * 1000; + } + + this.dispatch(info); + } + while(this._hasMoreData.value); + }, + dispatch: function(info) + { + // + // Notify the factory that the connection establishment and + // validation has completed. + // + if(this._startPromise !== null) + { + this._startPromise.succeed(); + this._startPromise = null; + } + + if(info !== null) + { + if(info.outAsync !== null) + { + info.outAsync.__finished(info.stream); + } + + if(info.invokeNum > 0) + { + this.invokeAll(info.stream, info.invokeNum, info.requestId, info.compress, info.servantManager, + info.adapter); + } + } + + // + // Decrease dispatch count. + // + if(info !== null && info.outAsync !== null) + { + if(--this._dispatchCount === 0) + { + if(this._state === StateClosing && !this._shutdownInitiated) + { + try + { + this.initiateShutdown(); + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.setStateEx(StateClosed, ex); + } + else + { + throw ex; + } + } + } + else if(this._state === StateFinished) + { + this._reaper.add(this); + } + this.checkState(); + } + } + }, + finish: function() + { + Debug.assert(this._state === StateClosed); + this.unscheduleTimeout(SocketOperation.Read | SocketOperation.Write | SocketOperation.Connect); + + if(this._startPromise !== null) + { + this._startPromise.fail(this._exception); + this._startPromise = null; + } + + if(this._sendStreams.length > 0) + { + if(!this._writeStream.isEmpty()) + { + // + // Return the stream to the outgoing call. This is important for + // retriable AMI calls which are not marshalled again. + // + var message = this._sendStreams[0]; + this._writeStream.swap(message.stream); + } + + // + // NOTE: for twoway requests which are not sent, finished can be called twice: the + // first time because the outgoing is in the _sendStreams set and the second time + // because it's either in the _requests/_asyncRequests set. This is fine, only the + // first call should be taken into account by the implementation of finished. + // + for(var i = 0; i < this._sendStreams.length; ++i) + { + var p = this._sendStreams[i]; + if(p.requestId > 0) + { + this._asyncRequests.delete(p.requestId); + } + p.finished(this._exception); + } + this._sendStreams = []; + } + + for(var e = this._asyncRequests.entries; e !== null; e = e.next) + { + e.value.__finishedEx(this._exception, true); + } + this._asyncRequests.clear(); + + // + // This must be done last as this will cause waitUntilFinished() to return (and communicator + // objects such as the timer might be destroyed too). + // + if(this._dispatchCount === 0) + { + this._reaper.add(this); + } + this.setState(StateFinished); + }, + toString: function() + { + return this._desc; + }, + timedOut: function(event) + { + if(this._state <= StateNotValidated) + { + this.setStateEx(StateClosed, new Ice.ConnectTimeoutException()); + } + else if(this._state < StateClosing) + { + this.setStateEx(StateClosed, new Ice.TimeoutException()); + } + else if(this._state === StateClosing) + { + this.setStateEx(StateClosed, new Ice.CloseTimeoutException()); + } + }, + type: function() + { + return this._type; + }, + timeout: function() + { + return this._endpoint.timeout(); + }, + getInfo: function() + { + if(this._state >= StateClosed) + { + throw this._exception; + } + var info = this._transceiver.getInfo(); + info.adapterName = this._adapter !== null ? this._adapter.getName() : ""; + info.incoming = this._incoming; + return info; + }, + exception: function(ex) + { + this.setStateEx(StateClosed, ex); + }, + invokeException: function(ex, invokeNum) + { + // + // Fatal exception while invoking a request. Since sendResponse/sendNoResponse isn't + // called in case of a fatal exception we decrement this._dispatchCount here. + // + + this.setStateEx(StateClosed, ex); + + if(invokeNum > 0) + { + Debug.assert(this._dispatchCount > 0); + this._dispatchCount -= invokeNum; + Debug.assert(this._dispatchCount >= 0); + if(this._dispatchCount === 0) + { + if(this._state === StateFinished) + { + this._reaper.add(this); + } + this.checkState(); + } + } + }, + setStateEx: function(state, ex) + { + Debug.assert(ex instanceof Ice.LocalException); + + // + // If setState() is called with an exception, then only closed + // and closing states are permissible. + // + Debug.assert(state >= StateClosing); + + if(this._state === state) // Don't switch twice. + { + return; + } + + if(this._exception === null) + { + this._exception = ex; + + // + // We don't warn if we are not validated. + // + if(this._warn && this._validated) + { + // + // Don't warn about certain expected exceptions. + // + if(!(this._exception instanceof Ice.CloseConnectionException || + this._exception instanceof Ice.ForcedCloseConnectionException || + this._exception instanceof Ice.ConnectionTimeoutException || + this._exception instanceof Ice.CommunicatorDestroyedException || + this._exception instanceof Ice.ObjectAdapterDeactivatedException || + (this._exception instanceof Ice.ConnectionLostException && this._state === StateClosing))) + { + this.warning("connection exception", this._exception); + } + } + } + + // + // We must set the new state before we notify requests of any + // exceptions. Otherwise new requests may retry on a + // connection that is not yet marked as closed or closing. + // + this.setState(state); + }, + setState: function(state) + { + // + // We don't want to send close connection messages if the endpoint + // only supports oneway transmission from client to server. + // + if(this._endpoint.datagram() && state === StateClosing) + { + state = StateClosed; + } + + // + // Skip graceful shutdown if we are destroyed before validation. + // + if(this._state <= StateNotValidated && state === StateClosing) + { + state = StateClosed; + } + + if(this._state === state) // Don't switch twice. + { + return; + } + + try + { + switch(state) + { + case StateNotInitialized: + { + Debug.assert(false); + break; + } + + case StateNotValidated: + { + if(this._state !== StateNotInitialized) + { + Debug.assert(this._state === StateClosed); + return; + } + // + // Register to receive validation message. + // + if(!this._endpoint.datagram() && !this._incoming) + { + // + // Once validation is complete, a new connection starts out in the + // Holding state. We only want to register the transceiver now if we + // need to receive data in order to validate the connection. + // + this._transceiver.register(); + } + break; + } + + case StateActive: + { + // + // Can only switch from holding or not validated to + // active. + // + if(this._state !== StateHolding && this._state !== StateNotValidated) + { + return; + } + this._transceiver.register(); + break; + } + + case StateHolding: + { + // + // Can only switch from active or not validated to + // holding. + // + if(this._state !== StateActive && this._state !== StateNotValidated) + { + return; + } + if(this._state === StateActive) + { + this._transceiver.unregister(); + } + break; + } + + case StateClosing: + { + // + // Can't change back from closed. + // + if(this._state >= StateClosed) + { + return; + } + if(this._state === StateHolding) + { + // We need to continue to read in closing state. + this._transceiver.register(); + } + break; + } + + case StateClosed: + { + if(this._state === StateFinished) + { + return; + } + this._transceiver.unregister(); + break; + } + + case StateFinished: + { + Debug.assert(this._state === StateClosed); + this._transceiver.close(); + this._communicator = null; + break; + } + } + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + var msg = "unexpected connection exception:\n " + this._desc + "\n" + ExUtil.toString(ex); + this._instance.initializationData().logger.error(msg); + } + else + { + throw ex; + } + } + + // + // We only register with the connection monitor if our new state + // is StateActive. Otherwise we unregister with the connection + // monitor, but only if we were registered before, i.e., if our + // old state was StateActive. + // + if(this._acmTimeout > 0) + { + if(state === StateActive) + { + this._instance.connectionMonitor().add(this); + } + else if(this._state === StateActive) + { + this._instance.connectionMonitor().remove(this); + } + } + + this._state = state; + + if(this._state === StateClosing && this._dispatchCount === 0) + { + try + { + this.initiateShutdown(); + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.setStateEx(StateClosed, ex); + } + else + { + throw ex; + } + } + } + else if(this._state === StateClosed) + { + this.finish(); + } + + this.checkState(); + }, + initiateShutdown: function() + { + Debug.assert(this._state === StateClosing); + Debug.assert(this._dispatchCount === 0); + Debug.assert(!this._shutdownInitiated); + + if(!this._endpoint.datagram()) + { + // + // Before we shut down, we send a close connection + // message. + // + var os = new BasicStream(this._instance, Protocol.currentProtocolEncoding, false); + os.writeBlob(Protocol.magic); + Protocol.currentProtocol.__write(os); + Protocol.currentProtocolEncoding.__write(os); + os.writeByte(Protocol.closeConnectionMsg); + os.writeByte(0); // compression status: always report 0 for CloseConnection. + os.writeInt(Protocol.headerSize); // Message size. + + var status = this.sendMessage(OutgoingMessage.createForStream(os, false, false)); + if((status & AsyncStatus.Sent) > 0) + { + // + // Schedule the close timeout to wait for the peer to close the connection. + // + this.scheduleTimeout(SocketOperation.Write, this.closeTimeout()); + } + + // + // The CloseConnection message should be sufficient. Closing the write + // end of the socket is probably an artifact of how things were done + // in IIOP. In fact, shutting down the write end of the socket causes + // problems on Windows by preventing the peer from using the socket. + // For example, the peer is no longer able to continue writing a large + // message after the socket is shutdown. + // + //this._transceiver.shutdownWrite(); + } + }, + initialize: function() + { + var s = this._transceiver.initialize(this._readStream.buffer, this._writeStream.buffer); + if(s != SocketOperation.None) + { + this.scheduleTimeout(s, this.connectTimeout()); + return false; + } + + // + // Update the connection description once the transceiver is initialized. + // + this._desc = this._transceiver.toString(); + this.setState(StateNotValidated); + return true; + }, + validate: function() + { + if(!this._endpoint.datagram()) // Datagram connections are always implicitly validated. + { + if(this._adapter !== null) // The server side has the active role for connection validation. + { + if(this._writeStream.size === 0) + { + this._writeStream.writeBlob(Protocol.magic); + Protocol.currentProtocol.__write(this._writeStream); + Protocol.currentProtocolEncoding.__write(this._writeStream); + this._writeStream.writeByte(Protocol.validateConnectionMsg); + this._writeStream.writeByte(0); // Compression status (always zero for validate connection). + this._writeStream.writeInt(Protocol.headerSize); // Message size. + TraceUtil.traceSend(this._writeStream, this._logger, this._traceLevels); + this._writeStream.prepareWrite(); + } + + if(this._writeStream.pos != this._writeStream.size && + !this._transceiver.write(this._writeStream.buffer)) + { + this.scheduleTimeout(SocketOperation.Write, this.connectTimeout()); + return false; + } + } + else // The client side has the passive role for connection validation. + { + if(this._readStream.size === 0) + { + this._readStream.resize(Protocol.headerSize); + this._readStream.pos = 0; + } + + if(this._readStream.pos !== this._readStream.size && + !this._transceiver.read(this._readStream.buffer, this._hasMoreData)) + { + this.scheduleTimeout(SocketOperation.Read, this.connectTimeout()); + return false; + } + + Debug.assert(this._readStream.pos === Protocol.headerSize); + this._readStream.pos = 0; + var m = this._readStream.readBlob(4); + if(m[0] !== Protocol.magic[0] || m[1] !== Protocol.magic[1] || + m[2] !== Protocol.magic[2] || m[3] !== Protocol.magic[3]) + { + var bme = new Ice.BadMagicException(); + bme.badMagic = m; + throw bme; + } + + this._readProtocol.__read(this._readStream); + Protocol.checkSupportedProtocol(this._readProtocol); + + this._readProtocolEncoding.__read(this._readStream); + Protocol.checkSupportedProtocolEncoding(this._readProtocolEncoding); + + var messageType = this._readStream.readByte(); + if(messageType !== Protocol.validateConnectionMsg) + { + throw new Ice.ConnectionNotValidatedException(); + } + this._readStream.readByte(); // Ignore compression status for validate connection. + var size = this._readStream.readInt(); + if(size !== Protocol.headerSize) + { + throw new Ice.IllegalMessageSizeException(); + } + TraceUtil.traceRecv(this._readStream, this._logger, this._traceLevels); + this._validated = true; + } + } + + this._writeStream.resize(0); + this._writeStream.pos = 0; + + this._readStream.resize(Protocol.headerSize); + this._readHeader = true; + this._readStream.pos = 0; + + return true; + }, + sendNextMessage: function() + { + if(this._sendStreams.length === 0) + { + return; + } + + Debug.assert(!this._writeStream.isEmpty() && this._writeStream.pos === this._writeStream.size); + try + { + while(true) + { + // + // Notify the message that it was sent. + // + var message = this._sendStreams.shift(); + this._writeStream.swap(message.stream); + message.sent(this); + + // + // If there's nothing left to send, we're done. + // + if(this._sendStreams.length === 0) + { + break; + } + + // + // If we are in the closed state, don't continue sending. + // + // The connection can be in the closed state if parseMessage + // (called before sendNextMessage by message()) closes the + // connection. + // + if(this._state >= StateClosed) + { + return; + } + + // + // Otherwise, prepare the next message stream for writing. + // + message = this._sendStreams[0]; + Debug.assert(!message.prepared); + var stream = message.stream; + + stream.pos = 10; + stream.writeInt(stream.size); + stream.prepareWrite(); + message.prepared = true; + + if(message.outAsync !== null) + { + TraceUtil.trace("sending asynchronous request", stream, this._logger, this._traceLevels); + } + else + { + TraceUtil.traceSend(stream, this._logger, this._traceLevels); + } + this._writeStream.swap(message.stream); + + // + // Send the message. + // + if(this._writeStream.pos != this._writeStream.size && + !this._transceiver.write(this._writeStream.buffer)) + { + Debug.assert(!this._writeStream.isEmpty()); + this.scheduleTimeout(SocketOperation.Write, this._endpoint.timeout()); + return; + } + } + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.setState(StateClosed, ex); + return; + } + else + { + throw ex; + } + } + + Debug.assert(this._writeStream.isEmpty()); + + // + // If all the messages were sent and we are in the closing state, we schedule + // the close timeout to wait for the peer to close the connection. + // + if(this._state === StateClosing) + { + this.scheduleTimeout(SocketOperation.Write, this.closeTimeout()); + } + }, + sendMessage: function(message) + { + if(this._sendStreams.length > 0) + { + message.doAdopt(); + this._sendStreams.push(message); + return AsyncStatus.Queued; + } + Debug.assert(this._state < StateClosed); + + Debug.assert(!message.prepared); + + var stream = message.stream; + stream.pos = 10; + stream.writeInt(stream.size); + stream.prepareWrite(); + message.prepared = true; + + TraceUtil.trace("sending asynchronous request", message.stream, this._logger, this._traceLevels); + + if(this._transceiver.write(message.stream.buffer)) + { + // + // Entire buffer was written immediately. + // + message.sent(this); + if(this._acmTimeout > 0) + { + this._acmAbsoluteTimeoutMillis = Date.now() + this._acmTimeout * 1000; + } + return AsyncStatus.Sent; + } + message.doAdopt(); + + this._writeStream.swap(message.stream); + this._sendStreams.push(message); + this.scheduleTimeout(SocketOperation.Write, this._endpoint.timeout()); + + return AsyncStatus.Queued; + }, + parseMessage: function() + { + Debug.assert(this._state > StateNotValidated && this._state < StateClosed); + + var info = new MessageInfo(this._instance); + + this._readStream.swap(info.stream); + this._readStream.resize(Protocol.headerSize); + this._readStream.pos = 0; + this._readHeader = true; + + // + // Connection is validated on first message. This is only used by + // setState() to check wether or not we can print a connection + // warning (a client might close the connection forcefully if the + // connection isn't validated). + // + this._validated = true; + + Debug.assert(info.stream.pos === info.stream.size); + + try + { + // + // We don't need to check magic and version here. This has already + // been done by the caller. + // + info.stream.pos = 8; + var messageType = info.stream.readByte(); + info.compress = info.stream.readByte(); + if(info.compress === 2) + { + var ex = new Ice.FeatureNotSupportedException(); + ex.unsupportedFeature = "Cannot uncompress compressed message"; + throw ex; + } + info.stream.pos = Protocol.headerSize; + + switch(messageType) + { + case Protocol.closeConnectionMsg: + { + TraceUtil.traceRecv(info.stream, this._logger, this._traceLevels); + if(this._endpoint.datagram()) + { + if(this._warn) + { + this._logger.warning("ignoring close connection message for datagram connection:\n" + + this._desc); + } + } + else + { + this.setStateEx(StateClosed, new Ice.CloseConnectionException()); + } + break; + } + + case Protocol.requestMsg: + { + if(this._state === StateClosing) + { + TraceUtil.trace("received request during closing\n" + + "(ignored by server, client will retry)", + info.stream, this._logger, this._traceLevels); + } + else + { + TraceUtil.traceRecv(info.stream, this._logger, this._traceLevels); + info.requestId = info.stream.readInt(); + info.invokeNum = 1; + info.servantManager = this._servantManager; + info.adapter = this._adapter; + ++this._dispatchCount; + } + break; + } + + case Protocol.requestBatchMsg: + { + if(this._state === StateClosing) + { + TraceUtil.trace("received batch request during closing\n" + + "(ignored by server, client will retry)", + info.stream, this._logger, this._traceLevels); + } + else + { + TraceUtil.traceRecv(info.stream, this._logger, this._traceLevels); + info.invokeNum = info.stream.readInt(); + if(info.invokeNum < 0) + { + info.invokeNum = 0; + throw new Ice.UnmarshalOutOfBoundsException(); + } + info.servantManager = this._servantManager; + info.adapter = this._adapter; + this._dispatchCount += info.invokeNum; + } + break; + } + + case Protocol.replyMsg: + { + TraceUtil.traceRecv(info.stream, this._logger, this._traceLevels); + info.requestId = info.stream.readInt(); + info.outAsync = this._asyncRequests.get(info.requestId); + this._asyncRequests.delete(info.requestId); + if(info.outAsync === undefined) + { + throw new Ice.UnknownRequestIdException(); + } + this.checkClose(); + break; + } + + case Protocol.validateConnectionMsg: + { + TraceUtil.traceRecv(info.stream, this._logger, this._traceLevels); + if(this._warn) + { + this._logger.warning("ignoring unexpected validate connection message:\n" + this._desc); + } + break; + } + + default: + { + TraceUtil.trace("received unknown message\n(invalid, closing connection)", + info.stream, this._logger, this._traceLevels); + throw new Ice.UnknownMessageException(); + } + } + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + if(this._endpoint.datagram()) + { + if(this._warn) + { + this._logger.warning("datagram connection exception:\n" + ex + '\n' + this._desc); + } + } + else + { + this.setStateEx(StateClosed, ex); + } + } + else + { + throw ex; + } + } + + return info; + }, + invokeAll: function(stream, invokeNum, requestId, compress, servantManager, adapter) + { + var inc = null; + try + { + while(invokeNum > 0) + { + // + // Prepare the invocation. + // + var response = !this._endpoint.datagram() && requestId !== 0; + inc = new IncomingAsync(this._instance, this, adapter, response, compress, requestId); + + // + // Dispatch the invocation. + // + inc.invoke(servantManager, stream); + + --invokeNum; + inc = null; + } + + stream.clear(); + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.invokeException(ex, invokeNum); + } + else + { + throw ex; + } + } + }, + scheduleTimeout: function(op, timeout) + { + if(timeout < 0) + { + return; + } + + var self = this; + if((op & SocketOperation.Read) !== 0) + { + this._readTimeoutId = this._timer.schedule(function() { self.timedOut(); }, timeout); + this._readTimeoutScheduled = true; + } + if((op & (SocketOperation.Write | SocketOperation.Connect)) !== 0) + { + this._writeTimeoutId = this._timer.schedule(function() { self.timedOut(); }, timeout); + this._writeTimeoutScheduled = true; + } + }, + unscheduleTimeout: function(op) + { + if((op & SocketOperation.Read) !== 0 && this._readTimeoutScheduled) + { + this._timer.cancel(this._readTimeoutId); + this._readTimeoutScheduled = false; + } + if((op & (SocketOperation.Write | SocketOperation.Connect)) !== 0 && this._writeTimeoutScheduled) + { + this._timer.cancel(this._writeTimeoutId); + this._writeTimeoutScheduled = false; + } + }, + connectTimeout: function() + { + var defaultsAndOverrides = this._instance.defaultsAndOverrides(); + if(defaultsAndOverrides.overrideConnectTimeout) + { + return defaultsAndOverrides.overrideConnectTimeoutValue; + } + else + { + return this._endpoint.timeout(); + } + }, + closeTimeout: function() + { + var defaultsAndOverrides = this._instance.defaultsAndOverrides(); + if(defaultsAndOverrides.overrideCloseTimeout) + { + return defaultsAndOverrides.overrideCloseTimeoutValue; + } + else + { + return this._endpoint.timeout(); + } + }, + warning: function(msg, ex) + { + this._logger.warning(msg + ":\n" + this._desc + "\n" + ExUtil.toString(ex)); + }, + checkState: function() + { + if(this._state < StateHolding || this._dispatchCount > 0) + { + return; + } + + var i; + if(this._holdPromises.length > 0) + { + for(i = 0; i < this._holdPromises.length; ++i) + { + this._holdPromises[i].succeed(); + } + this._holdPromises = []; + } + + // + // We aren't finished until the state is finished and all + // outstanding requests are completed. Otherwise we couldn't + // guarantee that there are no outstanding calls when deactivate() + // is called on the servant locators. + // + if(this._state === StateFinished && this._finishedPromises.length > 0) + { + // + // Clear the OA. See bug 1673 for the details of why this is necessary. + // + this._adapter = null; + + for(i = 0; i < this._finishedPromises.length; ++i) + { + this._finishedPromises[i].succeed(); + } + this._finishedPromises = []; + } + } + }); + + // DestructionReason. + ConnectionI.ObjectAdapterDeactivated = 0; + ConnectionI.CommunicatorDestroyed = 1; + + Ice.ConnectionI = ConnectionI; + global.Ice = Ice; + + var OutgoingMessage = Class({ + __init__: function() + { + this.stream = null; + this.outAsync = null; + this.compress = false; + this.requestId = 0; + this.prepared = false; + this.isSent = false; + }, + doAdopt: function() + { + if(this.adopt) + { + var stream = new BasicStream(this.stream.instance, Protocol.currentProtocolEncoding); + stream.swap(this.stream); + this.stream = stream; + this.adopt = false; + } + }, + sent: function(connection) + { + this.isSent = true; // The message is sent. + + if(this.outAsync !== null) + { + this.outAsync.__sent(connection); + } + }, + finished: function(ex) + { + if(this.outAsync !== null) + { + this.outAsync.__finishedEx(ex, this.isSent); + } + } + }); + + OutgoingMessage.createForStream = function(stream, compress, adopt) + { + var m = new OutgoingMessage(); + m.stream = stream; + m.compress = compress; + m.adopt = adopt; + m.isSent = false; + m.requestId = 0; + m.outAsync = null; + return m; + }; + + OutgoingMessage.create = function(out, stream, compress, requestId) + { + var m = new OutgoingMessage(); + m.stream = stream; + m.compress = compress; + m.outAsync = out; + m.requestId = requestId; + m.isSent = false; + m.adopt = false; + return m; + }; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ConnectionMonitor.js b/js/src/Ice/ConnectionMonitor.js new file mode 100644 index 00000000000..dffe8f945a8 --- /dev/null +++ b/js/src/Ice/ConnectionMonitor.js @@ -0,0 +1,114 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Debug"); + require("Ice/ExUtil"); + + var Ice = global.Ice || {}; + + var Debug = Ice.Debug; + var ExUtil = Ice.ExUtil; + + var ConnectionMonitor = Ice.Class({ + __init__: function(instance, interval) + { + this._instance = instance; + this._interval = interval; + this._scheduledInterval = 0; + this._timerToken = -1; + this._connections = []; + }, + destroy: function() + { + Debug.assert(this._instance !== null); + this._instance.timer().cancel(this._timerToken); + this._instance = null; + this._connections = null; + }, + checkIntervalForACM: function(acmTimeout) + { + if(acmTimeout <= 0) + { + return; + } + + // + // If Ice.MonitorConnections isn't set (_interval == 0), the given ACM is used + // to determine the check interval: 1/10 of the ACM timeout with a minmal value + // of 5 seconds and a maximum value of 5 minutes. + // + // Note: if Ice.MonitorConnections is set, the timer is scheduled only if ACM + // is configured for the communicator or some object adapters. + // + var interval; + if(this._interval === 0) + { + interval = Math.floor(Math.min(300, Math.max(5, acmTimeout / 10))); + } + else if(this._scheduledInterval === this._interval) + { + return; // Nothing to do, the timer is already scheduled. + } + else + { + interval = this._interval; + } + + // + // If no timer is scheduled yet or if the given ACM requires a smaller interval, + // we re-schedule the timer. + // + if(this._scheduledInterval === 0 || this._scheduledInterval > interval) + { + this._scheduledInterval = interval; + this._instance.timer().cancel(this._timerToken); + var self = this; + this._timerToken = this._instance.timer().scheduleRepeated( + function() { self.runTimerTask(); }, interval * 1000); + } + }, + add: function(connection) + { + Debug.assert(this._instance !== null); + this._connections.push(connection); + }, + remove: function(connection) + { + Debug.assert(this._instance !== null); + var pos = this._connections.indexOf(connection); + Debug.assert(pos !== -1); + this._connections.splice(pos, 1); + }, + runTimerTask: function() + { + var now = Date.now(); + for(var i = 0; i < this._connections.length; ++i) + { + try + { + this._connections[i].monitor(now); + } + catch(ex) + { + if(this._instance === null) + { + return; + } + var msg = "exception in connection monitor:\n" + ExUtil.toString(ex); + this._instance.initializationData().logger.error(msg); + } + } + } + }); + + Ice.ConnectionMonitor = ConnectionMonitor; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ConnectionReaper.js b/js/src/Ice/ConnectionReaper.js new file mode 100644 index 00000000000..af8faa2ef26 --- /dev/null +++ b/js/src/Ice/ConnectionReaper.js @@ -0,0 +1,39 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + + require("Ice/Class"); + + var Ice = global.Ice || {}; + + var ConnectionReaper = Ice.Class({ + __init__: function() + { + this._connections = []; + }, + add: function(connection) + { + this._connections.push(connection); + }, + swapConnections: function() + { + if(this._connections.length === 0) + { + return null; + } + var connections = this._connections; + this._connections = []; + return connections; + } + }); + + Ice.ConnectionReaper = ConnectionReaper; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ConnectionRequestHandler.js b/js/src/Ice/ConnectionRequestHandler.js new file mode 100644 index 00000000000..8027022d0c8 --- /dev/null +++ b/js/src/Ice/ConnectionRequestHandler.js @@ -0,0 +1,64 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Promise"); + require("Ice/Class"); + require("Ice/ReferenceMode"); + + var Ice = global.Ice || {}; + + var Promise = Ice.Promise; + var ReferenceMode = Ice.ReferenceMode; + + var ConnectionRequestHandler = Ice.Class({ + __init__: function(ref, connection, compress) + { + this._reference = ref; + this._response = ref.getMode() == ReferenceMode.ModeTwoway; + this._connection = connection; + this._compress = compress; + }, + prepareBatchRequest: function(out) + { + this._connection.prepareBatchRequest(out); + }, + finishBatchRequest: function(out) + { + this._connection.finishBatchRequest(out, this._compress); + }, + abortBatchRequest: function() + { + this._connection.abortBatchRequest(); + }, + sendAsyncRequest: function(out) + { + return this._connection.sendAsyncRequest(out, this._compress, this._response); + }, + flushAsyncBatchRequests: function(out) + { + return this._connection.flushAsyncBatchRequests(out); + }, + getReference: function() + { + return this._reference; + }, + getConnection: function() + { + return this._connection; + }, + onConnection: function(r) + { + r.succeed(this._connection, r); + } + }); + + Ice.ConnectionRequestHandler = ConnectionRequestHandler; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Debug.js b/js/src/Ice/Debug.js new file mode 100644 index 00000000000..01ea0a27282 --- /dev/null +++ b/js/src/Ice/Debug.js @@ -0,0 +1,28 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + + var Ice = global.Ice || {}; + + var Debug = { + assert: function(b, msg) + { + if(!b) + { + console.log(msg === undefined ? "assertion failed" : msg); + console.log(Error().stack); + process.exit(1); + } + } + }; + + Ice.Debug = Debug; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/DefaultsAndOverrides.js b/js/src/Ice/DefaultsAndOverrides.js new file mode 100644 index 00000000000..94da3a723c7 --- /dev/null +++ b/js/src/Ice/DefaultsAndOverrides.js @@ -0,0 +1,102 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/FormatType"); + require("Ice/EndpointTypes"); + require("Ice/Protocol"); + require("Ice/LocalException"); + + var Ice = global.Ice || {}; + + var FormatType = Ice.FormatType; + var EndpointSelectionType = Ice.EndpointSelectionType; + var Protocol = Ice.Protocol; + + var DefaultsAndOverrides = function(properties) + { + var value; + + this.defaultProtocol = properties.getPropertyWithDefault("Ice.Default.Protocol", + Ice.TcpEndpointFactory !== undefined ? "tcp" : "ws"); + + value = properties.getProperty("Ice.Default.Host"); + this.defaultHost = value.length > 0 ? value : null; + + value = properties.getProperty("Ice.Override.Timeout"); + if(value.length > 0) + { + this.overrideTimeout = true; + this.overrideTimeoutValue = properties.getPropertyAsInt("Ice.Override.Timeout"); + } + else + { + this.overrideTimeout = false; + this.overrideTimeoutValue = -1; + } + + value = properties.getProperty("Ice.Override.ConnectTimeout"); + if(value.length > 0) + { + this.overrideConnectTimeout = true; + this.overrideConnectTimeoutValue = properties.getPropertyAsInt("Ice.Override.ConnectTimeout"); + } + else + { + this.overrideConnectTimeout = false; + this.overrideConnectTimeoutValue = -1; + } + + value = properties.getProperty("Ice.Override.CloseTimeout"); + if(value.length > 0) + { + this.overrideCloseTimeout = true; + this.overrideCloseTimeoutValue = properties.getPropertyAsInt("Ice.Override.CloseTimeout"); + } + else + { + this.overrideCloseTimeout = false; + this.overrideCloseTimeoutValue = -1; + } + + this.overrideCompress = false; + this.overrideSecure = false; + + value = properties.getPropertyWithDefault("Ice.Default.EndpointSelection", "Random"); + if(value === "Random") + { + this.defaultEndpointSelection = EndpointSelectionType.Random; + } + else if(value === "Ordered") + { + this.defaultEndpointSelection = EndpointSelectionType.Ordered; + } + else + { + var ex = new Ice.EndpointSelectionTypeParseException(); + ex.str = "illegal value `" + value + "'; expected `Random' or `Ordered'"; + throw ex; + } + + this.defaultLocatorCacheTimeout = properties.getPropertyAsIntWithDefault("Ice.Default.LocatorCacheTimeout", -1); + + this.defaultPreferSecure = properties.getPropertyAsIntWithDefault("Ice.Default.PreferSecure", 0) > 0; + + value = properties.getPropertyWithDefault("Ice.Default.EncodingVersion", + Ice.encodingVersionToString(Protocol.currentEncoding)); + this.defaultEncoding = Ice.stringToEncodingVersion(value); + Protocol.checkSupportedEncoding(this.defaultEncoding); + + var slicedFormat = properties.getPropertyAsIntWithDefault("Ice.Default.SlicedFormat", 0) > 0; + this.defaultFormat = slicedFormat ? FormatType.SlicedFormat : FormatType.CompactFormat; + }; + + Ice.DefaultsAndOverrides = DefaultsAndOverrides; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/DispatchStatus.js b/js/src/Ice/DispatchStatus.js new file mode 100644 index 00000000000..3a20e36aae4 --- /dev/null +++ b/js/src/Ice/DispatchStatus.js @@ -0,0 +1,15 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + var Ice = global.Ice || {}; + var DispatchStatus = {DispatchOK: 0, DispatchUserException: 1, DispatchAsync: 2}; + Ice.DispatchStatus = DispatchStatus; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/EndpointFactoryManager.js b/js/src/Ice/EndpointFactoryManager.js new file mode 100644 index 00000000000..881c9cd998c --- /dev/null +++ b/js/src/Ice/EndpointFactoryManager.js @@ -0,0 +1,146 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/BasicStream"); + require("Ice/Debug"); + require("Ice/OpaqueEndpointI"); + require("Ice/Protocol"); + require("Ice/LocalException"); + + var Ice = global.Ice || {}; + + // + // Local aliases. + // + var Debug = Ice.Debug; + var BasicStream = Ice.BasicStream; + var EndpointParseException = Ice.EndpointParseException; + var OpaqueEndpointI = Ice.OpaqueEndpointI; + var Protocol = Ice.Protocol; + + var EndpointFactoryManager = Ice.Class({ + __init__: function(instance) + { + this._instance = instance; + this._factories = []; + }, + add: function(factory) + { + for(var i = 0; i < this._factories.length; ++i) + { + Debug.assert(this._factories[i].type() != factory.type()); + } + + this._factories.push(factory); + }, + get: function(type) + { + for(var i = 0; i < this._factories.length; ++i) + { + if(this._factories[i].type() === type) + { + return this._factories[i]; + } + } + return null; + }, + create: function(str, oaEndpoint) + { + var s = str.trim(); + if(s.length === 0) + { + throw new EndpointParseException("value has no non-whitespace characters"); + } + + var protocol; + var rest = ""; + var i, length; + var pos = s.search(/[ \t\n\r]+/); + if(pos === -1) + { + protocol = s; + } + else + { + protocol = s.substring(0, pos); + if(pos < s.length) + { + rest = s.substring(pos); + } + } + + if(protocol === "default") + { + protocol = this._instance.defaultsAndOverrides().defaultProtocol; + } + + for(i = 0, length = this._factories.length; i < length; ++i) + { + if(this._factories[i].protocol() === protocol) + { + return this._factories[i].create(rest, oaEndpoint); + } + } + + // + // If the stringified endpoint is opaque, create an unknown endpoint, + // then see whether the type matches one of the known endpoints. + // + if(protocol === "opaque") + { + var ue = OpaqueEndpointI.fromString(rest); + for(i = 0, length = this._factories.length; i < length; ++i) + { + if(this._factories[i].type() == ue.type()) + { + // + // Make a temporary stream, write the opaque endpoint data into the stream, + // and ask the factory to read the endpoint data from that stream to create + // the actual endpoint. + // + var bs = new BasicStream(this._instance, Protocol.currentProtocolEncoding, true); + ue.streamWrite(bs); + bs.pos = 0; + bs.readShort(); // type + return this._factories[i].read(bs); + } + } + return ue; // Endpoint is opaque, but we don't have a factory for its type. + } + + return null; + }, + read: function(s) + { + var type = s.readShort(); + + for(var i = 0; i < this._factories.length; ++i) + { + if(this._factories[i].type() == type) + { + return this._factories[i].read(s); + } + } + return OpaqueEndpointI.fromStream(type, s); + }, + destroy: function() + { + for(var i = 0; i < this._factories.length; ++i) + { + this._factories[i].destroy(); + } + this._factories = []; + } + }); + + Ice.EndpointFactoryManager = EndpointFactoryManager; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/EnumBase.js b/js/src/Ice/EnumBase.js new file mode 100644 index 00000000000..a387219e81c --- /dev/null +++ b/js/src/Ice/EnumBase.js @@ -0,0 +1,163 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + + var Slice = global.Slice || {}; + var Ice = global.Ice || {}; + // + // Ice.EnumBase + // + var EnumBase = Ice.Class({ + __init__: function(name, value) + { + this._name = name; + this._value = value; + }, + equals: function(rhs) + { + if(this === rhs) + { + return true; + } + + var proto = Object.getPrototypeOf(this); + if(!(rhs instanceof proto.constructor)) + { + return false; + } + + return this._value == rhs._value; + }, + hashCode: function() + { + return this._value; + }, + toString: function() + { + return this._name; + } + }); + + var prototype = EnumBase.prototype; + + Object.defineProperty(prototype, 'name', { + enumerable: true, + get: function() { return this._name; } + }); + + Object.defineProperty(prototype, 'value', { + enumerable: true, + get: function() { return this._value; } + }); + + var EnumHelper = Ice.Class({ + __init__: function(enumType) + { + this._enumType = enumType; + }, + write: function(os, v) + { + this._enumType.__write(os, v); + }, + writeOpt: function(os, tag, v) + { + this._enumType.__writeOpt(os, tag, v); + }, + read: function(is) + { + return this._enumType.__read(is); + }, + readOpt: function(is, tag) + { + return this._enumType.__readOpt(is, tag); + } + }); + + Ice.EnumHelper = EnumHelper; + + var write = function(os, v) + { + os.writeEnum(v); + }; + var writeOpt = function(os, tag, v) + { + os.writeOptValue(tag, Ice.OptionalFormat.Size, Ice.BasicStream.prototype.writeEnum, v); + }; + + Slice.defineEnum = function(enumerators) + { + var type = function(n, v) + { + EnumBase.call(this, n, v); + }; + + type.prototype = new EnumBase(); + type.prototype.constructor = type; + + var enums = []; + var maxValue = 0; + for(var e in enumerators) + { + var value = enumerators[e]; + var enumerator = new type(e, value); + enums[value] = enumerator; + Object.defineProperty(type, e, { + enumerable: true, + value: enumerator + }); + if(value > maxValue) + { + maxValue = value; + } + } + + Object.defineProperty(type, "minWireSize", { + get: function(){ return 1; } + }); + + type.__write = write; + type.__read = function(is) + { + return is.readEnum(type); + }; + type.__writeOpt = writeOpt; + type.__readOpt = function(is, tag) + { + return is.readOptEnum(tag, type); + }; + + type.__helper = new EnumHelper(type); + + Object.defineProperty(type, 'valueOf', { + value: function(v) { + if(v === undefined) + { + return type; + } + return enums[v]; } + }); + + Object.defineProperty(type, 'maxValue', { + value: maxValue + }); + + Object.defineProperty(type.prototype, 'maxValue', { + value: maxValue + }); + + return type; + }; + + Ice.EnumBase = EnumBase; + + global.Slice = Slice; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ExUtil.js b/js/src/Ice/ExUtil.js new file mode 100644 index 00000000000..c2fc0f0669d --- /dev/null +++ b/js/src/Ice/ExUtil.js @@ -0,0 +1,53 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + // + // Exception utilities + // + + require("Ice/LocalException"); + + var Ice = global.Ice || {}; + + // + // Local aliases. + // + var UnexpectedObjectException = Ice.UnexpectedObjectException; + var MemoryLimitException = Ice.MemoryLimitException; + var ExUtil = {}; + + ExUtil.toString = function(ex) + { + if(!ex.stack) + { + return ex.toString(); + } + else + { + return ex.stack; + } + }; + + ExUtil.throwUOE = function(expectedType, v) + { + var type = v.ice_id(); + throw new UnexpectedObjectException("expected element of type `" + expectedType + "' but received '" + + type, type, expectedType); + }; + + ExUtil.throwMemoryLimitException = function(requested, maximum) + { + throw new MemoryLimitException("requested " + requested + " bytes, maximum allowed is " + maximum + + " bytes (see Ice.MessageSizeMax)"); + }; + + Ice.ExUtil = ExUtil; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Exception.js b/js/src/Ice/Exception.js new file mode 100644 index 00000000000..032ace3339d --- /dev/null +++ b/js/src/Ice/Exception.js @@ -0,0 +1,241 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + + var Slice = global.Slice || {}; + var Ice = global.Ice || {}; + + var Class = Ice.Class; + + // + // Ice.Exception + // + var Exception = Class(Error, { + __init__: function(cause) + { + this.ice_cause = cause; + }, + ice_name: function() + { + return "Ice::Exception"; + }, + toString: function() + { + var s = this.ice_name(); + for(var key in this) + { + if(key == "stack" || key.indexOf("_") === 0) + { + continue; + } + + var value = this[key]; + if(typeof value == "function") + { + continue; + } + + s += "\n " + key + ": \"" + value + "\""; + } + return s; + } + }); + + Exception.captureStackTrace = function(object) + { + var stack = new Error().stack; + + var formattedStack; + + // + // In IE 10 and greater the stack will be filled once the Error is throw + // we don't need to do anything. + // + if(stack !== undefined) + { + + var name = object.ice_name ? object.ice_name().replace("::", ".") : ""; + Object.defineProperty(object, "stack", { + get: function(){ + return stack; + } + }); + } + }; + + Ice.Exception = Exception; + + // + // Ice.LocalException + // + var LocalException = Class(Exception, { + __init__: function(cause) + { + Exception.call(this, cause); + Exception.captureStackTrace(this); + }, + ice_name: function() + { + return "Ice::LocalException"; + } + }); + + Ice.LocalException = LocalException; + + Slice.defineLocalException = function(constructor, base, name) + { + var ex = constructor; + ex.prototype = new base(); + ex.prototype.constructor = ex; + ex.prototype.ice_name = function() + { + return name; + }; + return ex; + }; + + // + // Ice.UserException + // + var UserException = Class(Exception, { + __init__: function(cause) + { + Exception.call(this, cause); + Exception.captureStackTrace(this); + }, + ice_name: function() + { + return "Ice::UserException"; + }, + __write: function(os) + { + os.startWriteException(null); + __writeImpl(this, os, this.__mostDerivedType()); + os.endWriteException(); + }, + __read: function(is) + { + is.startReadException(); + __readImpl(this, is, this.__mostDerivedType()); + is.endReadException(false); + }, + __usesClasses: function() + { + return false; + } + }); + Ice.UserException = UserException; + + // + // Private methods + // + + var __writeImpl = function(obj, os, type) + { + // + // The __writeImpl method is a recursive method that goes down the + // class hierarchy to marshal each slice of the class using the + // generated __writeMemberImpl method. + // + + if(type === undefined || type === UserException) + { + return; // Don't marshal anything for Ice.UserException + } + + os.startWriteSlice(type.__id, -1, type.__parent === UserException); + if(type.prototype.__writeMemberImpl) + { + type.prototype.__writeMemberImpl.call(obj, os); + } + os.endWriteSlice(); + __writeImpl(obj, os, type.__parent); + }; + + var __readImpl = function(obj, is, type) + { + // + // The __readImpl method is a recursive method that goes down the + // class hierarchy to marshal each slice of the class using the + // generated __readMemberImpl method. + // + + if(type === undefined || type === UserException) + { + return; // Don't marshal anything for UserException + } + + is.startReadSlice(); + if(type.prototype.__readMemberImpl) + { + type.prototype.__readMemberImpl.call(obj, is); + } + is.endReadSlice(); + __readImpl(obj, is, type.__parent); + }; + + var __writePreserved = function(os) + { + // + // For Slice exceptions which are marked "preserved", the implementation of this method + // replaces the Ice.Object.prototype.__write method. + // + os.startWriteException(this.__slicedData); + __writeImpl(this, os, this.__mostDerivedType()); + os.endWriteException(); + }; + + var __readPreserved = function(is) + { + // + // For Slice exceptions which are marked "preserved", the implementation of this method + // replaces the Ice.Object.prototype.__read method. + // + is.startReadException(); + __readImpl(this, is, this.__mostDerivedType()); + this.__slicedData = is.endReadException(true); + }; + + Slice.defineUserException = function(constructor, base, name, writeImpl, readImpl, preserved, usesClasses) + { + var ex = constructor; + ex.__parent = base; + ex.prototype = new base(); + ex.__id = "::" + name; + ex.prototype.ice_name = function() + { + return name; + }; + + ex.prototype.constructor = ex; + ex.prototype.__mostDerivedType = function() { return ex; }; + if(preserved) + { + ex.prototype.__write = __writePreserved; + ex.prototype.__read = __readPreserved; + } + ex.prototype.__writeMemberImpl = writeImpl; + ex.prototype.__readMemberImpl = readImpl; + + if(usesClasses) + { + ex.prototype.__usesClasses = function() + { + return true; + }; + } + + return ex; + }; + + global.Slice = Slice; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/FormatType.js b/js/src/Ice/FormatType.js new file mode 100644 index 00000000000..0cc2820e780 --- /dev/null +++ b/js/src/Ice/FormatType.js @@ -0,0 +1,18 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/EnumBase"); + + var Ice = global.Ice || {}; + + Ice.FormatType = Slice.defineEnum({'DefaultFormat':0, 'CompactFormat':1, 'SlicedFormat':2}); + + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/HashMap.js b/js/src/Ice/HashMap.js new file mode 100644 index 00000000000..aa09448c85b --- /dev/null +++ b/js/src/Ice/HashMap.js @@ -0,0 +1,417 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/StringUtil"); + + var Slice = global.Slice || {}; + var Ice = global.Ice || {}; + + var StringUtil = Ice.StringUtil; + + function setInternal(map, key, value, hash, index) + { + // + // Search for an entry with the same key. + // + for(var e = map._table[index]; e !== null; e = e._nextInBucket) + { + if(e._hash === hash && map.keysEqual(key, e._key)) + { + // + // Found a match, update the value. + // + e._value = value; + return undefined; + } + } + + // + // No match found, add a new entry. + // + map.add(key, value, hash, index); + return undefined; + } + + var HashMap = Ice.Class({ + __init__: function(h) + { + this._size = 0; + this._head = null; + this._initialCapacity = 32; + this._loadFactor = 0.75; + this._table = []; + this._keyComparator = function(k1, k2) { return k1 === k2; }; + this._valueComparator = function(k1, k2) { return k1 === k2; }; + + var i, length; + if(h === undefined || h === null || h._size === 0) + { + this._threshold = this._initialCapacity * this._loadFactor; + for(i = 0; i < this._initialCapacity; i++) + { + this._table[i] = null; + } + } + else + { + this._threshold = h._threshold; + this._keyComparator = h._keyComparator; + this._valueComparator = h._valueComparator; + length = h._table.length; + this._table.length = length; + for(i = 0; i < length; i++) + { + this._table[i] = null; + } + this.merge(h); + } + }, + set: function(key, value) + { + var hash = this.computeHash(key); + + var index = this.hashIndex(hash, this._table.length); + + return setInternal(this, key, value, hash, index); + }, + get: function(key) + { + var e = this.findEntry(key, this.computeHash(key)); + return e !== undefined ? e._value : undefined; + }, + has: function(key) + { + return this.findEntry(key, this.computeHash(key)) !== undefined; + }, + delete: function(key) + { + var hash = this.computeHash(key); + + var index = this.hashIndex(hash, this._table.length); + + // + // Search for an entry with the same key. + // + var prev = null; + for(var e = this._table[index]; e !== null; e = e._nextInBucket) + { + if(e._hash === hash && this.keysEqual(key, e._key)) + { + // + // Found a match. + // + this._size--; + + // + // Remove from bucket. + // + if(prev !== null) + { + prev._nextInBucket = e._nextInBucket; + } + else + { + this._table[index] = e._nextInBucket; + } + + // + // Unlink the entry. + // + if(e._prev !== null) + { + e._prev._next = e._next; + } + if(e._next !== null) + { + e._next._prev = e._prev; + } + + if(this._head === e) + { + this._head = e._next; + } + + return e._value; + } + + prev = e; + } + + return undefined; + }, + clear: function() + { + for(var i = 0; i < this._table.length; ++i) + { + this._table[i] = null; + } + this._head = null; + this._size = 0; + }, + forEach: function(fn, obj) + { + obj = obj === undefined ? fn : obj; + for(var e = this._head; e !== null; e = e._next) + { + fn.call(obj, e._key, e._value); + } + }, + equals: function(other) + { + if(other === null || !(other instanceof HashMap) || this._size !== other._size) + { + return false; + } + + for(var e = this._head; e !== null; e = e._next) + { + var oe = other.findEntry(e._key, e._hash); + if(oe === undefined || !this.valuesEqual(e._value, oe._value)) + { + return false; + } + } + + return true; + }, + clone: function() + { + return new HashMap(this); + }, + merge: function(from) + { + for(var e = from._head; e !== null; e = e._next) + { + setInternal(this, e._key, e._value, e._hash, this.hashIndex(e._hash, this._table.length)); + } + }, + add: function(key, value, hash, index) + { + // + // Create a new table entry. + // + /* + var e = + { + key: key, + value: value, + prev: null, + next: null, + _hash: hash + } + */ + var e = Object.create(null, { + "key": { + enumerable: true, + get: function() { return this._key; } + }, + "value": { + enumerable: true, + get: function() { return this._value; } + }, + "next": { + enumerable: true, + get: function() { return this._next; } + }, + "_key": { + enumerable: false, + writable: true, + value: key + }, + "_value": { + enumerable: false, + writable: true, + value: value + }, + "_prev": { + enumerable: false, + writable: true, + value: null + }, + "_next": { + enumerable: false, + writable: true, + value: null + }, + "_nextInBucket": { + enumerable: false, + writable: true, + value: null + }, + "_hash": { + enumerable: false, + writable: true, + value: hash + } + }); + e._nextInBucket = this._table[index]; + this._table[index] = e; + + e._next = this._head; + if(this._head !== null) + { + this._head._prev = e; + } + this._head = e; + + this._size++; + if(this._size >= this._threshold) + { + this.resize(this._table.length * 2); + } + }, + resize: function(capacity) + { + var oldTable = this._table; + + var newTable = []; + for(var i = 0; i < capacity; i++) + { + newTable[i] = null; + } + + // + // Re-assign all entries to buckets. + // + for(var e = this._head; e !== null; e = e._next) + { + var index = this.hashIndex(e._hash, capacity); + e._nextInBucket = newTable[index]; + newTable[index] = e; + } + + this._table = newTable; + this._threshold = (capacity * this._loadFactor); + }, + findEntry: function(key, hash) + { + var index = this.hashIndex(hash, this._table.length); + + // + // Search for an entry with the same key. + // + for(var e = this._table[index]; e !== null; e = e._nextInBucket) + { + if(e._hash === hash && this.keysEqual(key, e._key)) + { + return e; + } + } + + return undefined; + }, + hashIndex: function(hash, len) + { + return hash & (len - 1); + }, + computeHash: function(v) + { + if(typeof(v.hashCode) === "function") + { + return v.hashCode(); + } + + var hash = 0; + var type = typeof(v); + if(type === "string" || v instanceof String) + { + hash = StringUtil.hashCode(v); + } + else if(type === "number" || v instanceof Number) + { + hash = v.toFixed(0); + } + else if(type === "boolean" || v instanceof Boolean) + { + hash = v ? 1 : 0; + } + else if(v !== null) + { + throw "cannot compute hash for value of type " + type; + } + return hash; + }, + keysEqual: function(k1, k2) + { + return this._keyComparator.call(this._keyComparator, k1, k2); + }, + valuesEqual: function(v1, v2) + { + return this._valueComparator.call(this._valueComparator, v1, v2); + } + }); + + var prototype = HashMap.prototype; + + Object.defineProperty(prototype, "size", { + get: function() { return this._size; } + }); + + Object.defineProperty(prototype, "entries", { + get: function() { return this._head; } + }); + + Object.defineProperty(prototype, "keyComparator", { + get: function() { return this._keyComparator; }, + set: function(fn) { this._keyComparator = fn; } + }); + + Object.defineProperty(prototype, "valueComparator", { + get: function() { return this._valueComparator; }, + set: function(fn) { this._valueComparator = fn; } + }); + + Object.defineProperty(HashMap, "compareEquals", { + get: function() { return function(o1, o2) { return o1.equals(o2); }; } + }); + + Slice.defineDictionary = function(module, name, helperName, keyHelper, valueHelper, fixed, useEquals, valueType) + { + if(useEquals) + { + // + // Define a constructor function for a dictionary whose key type requires + // comparison using an equals() method instead of the native comparison + // operators. + // + module[name] = function(h) + { + var r = new HashMap(h); + r.keyComparator = HashMap.compareEquals; + return r; + }; + } + else + { + module[name] = HashMap; + } + + var helper = null; + Object.defineProperty(module, helperName, + { + get: function() + { + if(helper === null) + { + /*jshint -W061 */ + helper = Ice.StreamHelpers.generateDictHelper(eval(keyHelper), eval(valueHelper), fixed, + eval(valueType), module[name]); + /*jshint +W061 */ + } + return helper; + } + }); + }; + + Ice.HashMap = HashMap; + global.Slice = Slice; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/HashUtil.js b/js/src/Ice/HashUtil.js new file mode 100644 index 00000000000..7fe2f3f0c8a --- /dev/null +++ b/js/src/Ice/HashUtil.js @@ -0,0 +1,61 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/StringUtil"); + + var Ice = global.Ice || {}; + + var StringUtil = Ice.StringUtil; + + var HashUtil = {}; + + HashUtil.addBoolean = function(h, b) + { + return ((h << 5) + h) ^ (b ? 0 : 1); + }; + + HashUtil.addString = function(h, str) + { + if(str !== undefined && str !== null) + { + h = ((h << 5) + h) ^ StringUtil.hashCode(str); + } + return h; + }; + + HashUtil.addNumber = function(h, num) + { + return ((h << 5) + h) ^ num; + }; + + HashUtil.addHashable = function(h, obj) + { + if(obj !== undefined && obj !== null) + { + h = ((h << 5) + h) ^ obj.hashCode(); + } + return h; + }; + + HashUtil.addArray = function(h, arr, hashCode) + { + if(arr !== undefined && arr !== null) + { + for(var i = 0; i < arr.length; ++i) + { + h = hashCode(h, arr[i]); + } + } + return h; + }; + + Ice.HashUtil = HashUtil; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Ice.js b/js/src/Ice/Ice.js new file mode 100644 index 00000000000..d7ec2f807bd --- /dev/null +++ b/js/src/Ice/Ice.js @@ -0,0 +1,39 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(){ + require("Ice/TcpEndpointFactory"); // Must be loaded before Communicator and Instance + require("Ice/Initialize"); + require("Ice/Communicator"); + require("Ice/HashMap"); + require("Ice/Object"); + require("Ice/Long"); + require("Ice/Logger"); + require("Ice/ObjectPrx"); + require("Ice/Metrics"); + require("Ice/Properties"); + require("Ice/IdentityUtil"); + require("Ice/ProcessLogger"); + require("Ice/Protocol"); + require("Ice/Identity"); + require("Ice/Exception"); + require("Ice/LocalException"); + require("Ice/BuiltinSequences"); + require("Ice/StreamHelpers"); + require("Ice/Promise"); + require("Ice/EndpointTypes"); + require("Ice/Locator"); + require("Ice/Router"); + require("Ice/Version"); + require("Ice/ObjectFactory"); + require("Ice/Buffer"); + require("Ice/ArrayUtil"); + require("Ice/UnknownSlicedObject"); + require("Ice/Process"); +}()); diff --git a/js/src/Ice/IdentityUtil.js b/js/src/Ice/IdentityUtil.js new file mode 100644 index 00000000000..660e9043eef --- /dev/null +++ b/js/src/Ice/IdentityUtil.js @@ -0,0 +1,228 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/ExUtil"); + require("Ice/StringUtil"); + require("Ice/Identity"); + require("Ice/LocalException"); + + var Ice = global.Ice || {}; + + var ExUtil = Ice.ExUtil; + var StringUtil = Ice.StringUtil; + var Identity = Ice.Identity; + var IdentityParseException = Ice.IdentityParseException; + + Ice = global.Ice || {}; + /** + * Converts a string to an object identity. + * + * @param s The string to convert. + * + * @return The converted object identity. + **/ + Ice.stringToIdentity = function(s) + { + var ident = new Identity(); + + // + // Find unescaped separator. + // + var slash = -1; + var pos = 0; + while((pos = s.indexOf('/', pos)) !== -1) + { + if(pos === 0 || s.charAt(pos - 1) != '\\') + { + if(slash == -1) + { + slash = pos; + } + else + { + // + // Extra unescaped slash found. + // + var ex = new IdentityParseException(); + ex.str = "unescaped backslash in identity `" + s + "'"; + throw ex; + } + } + pos++; + } + + if(slash == -1) + { + ident.category = ""; + try + { + ident.name = StringUtil.unescapeString(s); + } + catch(e) + { + var ex = new IdentityParseException(); + ex.str = "invalid identity name `" + s + "': " + ExUtil.toString(e); + throw ex; + } + } + else + { + try + { + ident.category = StringUtil.unescapeString(s, 0, slash); + } + catch(e) + { + var ex = new IdentityParseException(); + ex.str = "invalid category in identity `" + s + "': " + ExUtil.toString(e); + throw ex; + } + if(slash + 1 < s.length) + { + try + { + ident.name = StringUtil.unescapeString(s, slash + 1, s.length); + } + catch(e) + { + var ex = new IdentityParseException(); + ex.str = "invalid name in identity `" + s + "': " + ExUtil.toString(e); + throw ex; + } + } + else + { + ident.name = ""; + } + } + + return ident; + }; + + /** + * Converts an object identity to a string. + * + * @param ident The object identity to convert. + * + * @return The string representation of the object identity. + **/ + Ice.identityToString = function(ident) + { + if(ident.category === null || ident.category.length === 0) + { + return StringUtil.escapeString(ident.name, "/"); + } + else + { + return StringUtil.escapeString(ident.category, "/") + '/' + StringUtil.escapeString(ident.name, "/"); + } + }; + + /** + * Compares the object identities of two proxies. + * + * @param lhs A proxy. + * @param rhs A proxy. + * @return -1 if the identity in <code>lhs</code> compares + * less than the identity in <code>rhs</code>; 0 if the identities + * compare equal; 1, otherwise. + * + * @see ProxyIdentityKey + * @see ProxyIdentityAndFacetKey + * @see ProxyIdentityAndFacetCompare + **/ + Ice.proxyIdentityCompare = function(lhs, rhs) + { + if(lhs === rhs) + { + return 0; + } + else if(lhs === null && rhs !== null) + { + return -1; + } + else if(lhs !== null && rhs === null) + { + return 1; + } + else + { + var lhsIdentity = lhs.ice_getIdentity(); + var rhsIdentity = rhs.ice_getIdentity(); + var n; + if((n = lhsIdentity.name.localeCompare(rhsIdentity.name)) !== 0) + { + return n; + } + return lhsIdentity.category.localeCompare(rhsIdentity.category); + } + }; + + /** + * Compares the object identities and facets of two proxies. + * + * @param lhs A proxy. + * @param rhs A proxy. + * @return -1 if the identity and facet in <code>lhs</code> compare + * less than the identity and facet in <code>rhs</code>; 0 if the identities + * and facets compare equal; 1, otherwise. + * + * @see ProxyIdentityAndFacetKey + * @see ProxyIdentityKey + * @see ProxyIdentityCompare + **/ + Ice.proxyIdentityAndFacetCompare = function(lhs, rhs) + { + if(lhs === rhs) + { + return 0; + } + else if(lhs === null && rhs !== null) + { + return -1; + } + else if(lhs !== null && rhs === null) + { + return 1; + } + else + { + var lhsIdentity = lhs.ice_getIdentity(); + var rhsIdentity = rhs.ice_getIdentity(); + var n; + if((n = lhsIdentity.name.localeCompare(rhsIdentity.name)) !== 0) + { + return n; + } + if((n = lhsIdentity.category.localeCompare(rhsIdentity.category)) !== 0) + { + return n; + } + + var lhsFacet = lhs.ice_getFacet(); + var rhsFacet = rhs.ice_getFacet(); + if(lhsFacet === null && rhsFacet === null) + { + return 0; + } + else if(lhsFacet === null) + { + return -1; + } + else if(rhsFacet === null) + { + return 1; + } + return lhsFacet.localeCompare(rhsFacet); + } + }; + + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ImplicitContextI.js b/js/src/Ice/ImplicitContextI.js new file mode 100644 index 00000000000..c05f1452e58 --- /dev/null +++ b/js/src/Ice/ImplicitContextI.js @@ -0,0 +1,145 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/HashMap"); + require("Ice/LocalException"); + require("Ice/Current"); + require("Ice/Class"); + + var Ice = global.Ice || {}; + + var HashMap = Ice.HashMap; + var InitializationException = Ice.InitializationException; + + // + // The base class for all ImplicitContext implementations + // + var ImplicitContextI = Ice.Class({ + __init__: function() + { + this._context = new HashMap(); + }, + getContext: function() + { + return new HashMap(this._context); + }, + setContext: function(context) + { + if(context !== null && context.size > 0) + { + this._context = new HashMap(context); + } + else + { + this._context.clear(); + } + }, + containsKey: function(key) + { + if(key === null) + { + key = ""; + } + + return this._context.has(key); + }, + get: function(key) + { + if(key === null) + { + key = ""; + } + + var val = this._context.get(key); + if(val === null) + { + val = ""; + } + + return val; + }, + put: function(key, value) + { + if(key === null) + { + key = ""; + } + if(value === null) + { + value = ""; + } + + var oldVal = this._context.get(key); + if(oldVal === null) + { + oldVal = ""; + } + + this._context.set(key, value); + + return oldVal; + }, + remove: function(key) + { + if(key === null) + { + key = ""; + } + + var val = this._context.get(key); + this._context.delete(key); + + if(val === null) + { + val = ""; + } + return val; + }, + write: function(prxContext, os) + { + if(prxContext.size === 0) + { + Ice.ContextHelper.write(os, this._context); + } + else + { + var ctx = null; + if(this._context.size === 0) + { + ctx = prxContext; + } + else + { + ctx = new HashMap(this._context); + ctx.merge(prxContext); + } + Ice.ContextHelper.write(os, ctx); + } + } + }); + + ImplicitContextI.create = function(kind) + { + if(kind.length === 0 || kind === "None") + { + return null; + } + else if(kind === "Shared") + { + return new ImplicitContextI(); + } + else + { + throw new InitializationException("'" + kind + "' is not a valid value for Ice.ImplicitContext"); + } + }; + Ice.ImplicitContextI = ImplicitContextI; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/IncomingAsync.js b/js/src/Ice/IncomingAsync.js new file mode 100644 index 00000000000..54587639ae1 --- /dev/null +++ b/js/src/Ice/IncomingAsync.js @@ -0,0 +1,673 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/BasicStream"); + require("Ice/BuiltinSequences"); + require("Ice/Connection"); + require("Ice/Current"); + require("Ice/Debug"); + require("Ice/DispatchStatus"); + require("Ice/Exception"); + require("Ice/HashMap"); + require("Ice/Identity"); + require("Ice/LocalException"); + require("Ice/Protocol"); + require("Ice/StringUtil"); + + var Ice = global.Ice || {}; + + var BasicStream = Ice.BasicStream; + var Current = Ice.Current; + var Debug = Ice.Debug; + var FormatType = Ice.FormatType; + var HashMap = Ice.HashMap; + var Identity = Ice.Identity; + var Protocol = Ice.Protocol; + var StringUtil = Ice.StringUtil; + + var IncomingAsync = Ice.Class({ + __init__: function(instance, connection, adapter, response, compress, requestId) + { + this._instance = instance; + this._response = response; + this._compress = compress; + if(this._response) + { + this._os = new BasicStream(instance, Protocol.currentProtocolEncoding); + } + this._connection = connection; + + this._current = new Current(); + this._current.id = new Identity(); + this._current.adapter = adapter; + this._current.con = this._connection; + this._current.requestId = requestId; + + this._servant = null; + this._locator = null; + this._cookie = { value: null }; + + // + // Prepare the response if necessary. + // + if(response) + { + this._os.writeBlob(Protocol.replyHdr); + + // + // Add the request ID. + // + this._os.writeInt(requestId); + } + + this._is = null; + + this._cb = null; + this._active = true; + }, + __startWriteParams: function(format) + { + if(this._response) + { + Debug.assert(this._os.size == Protocol.headerSize + 4); // Reply status position. + Debug.assert(this._current.encoding !== null); // Encoding for reply is known. + this._os.writeByte(0); + this._os.startWriteEncaps(this._current.encoding, format); + } + + // + // We still return the stream even if no response is expected. The + // servant code might still write some out parameters if for + // example a method with out parameters somehow and erroneously + // invoked as oneway (or if the invocation is invoked on a + // blobject and the blobject erroneously writes a response). + // + return this._os; + }, + __endWriteParams: function(ok) + { + if(this._response) + { + var save = this._os.pos; + this._os.pos = Protocol.headerSize + 4; // Reply status position. + this._os.writeByte(ok ? Protocol.replyOK : Protocol.replyUserException); + this._os.pos = save; + this._os.endWriteEncaps(); + } + }, + __writeEmptyParams: function() + { + if(this._response) + { + Debug.assert(this._os.size === Protocol.headerSize + 4); // Reply status position. + Debug.assert(this._current.encoding !== null); // Encoding for reply is known. + this._os.writeByte(Protocol.replyOK); + this._os.writeEmptyEncaps(this._current.encoding); + } + }, + __writeParamEncaps: function(v, ok) + { + if(this._response) + { + Debug.assert(this._os.size === Protocol.headerSize + 4); // Reply status position. + Debug.assert(this._current.encoding !== null); // Encoding for reply is known. + this._os.writeByte(ok ? Protocol.replyOK : Protocol.replyUserException); + if(v === null || v.length === 0) + { + this._os.writeEmptyEncaps(this._current.encoding); + } + else + { + this._os.writeEncaps(v); + } + } + }, + __writeUserException: function(ex, format) + { + var os = this.__startWriteParams(format); + os.writeUserException(ex); + this.__endWriteParams(false); + }, + __warning: function(ex) + { + Debug.assert(this._instance !== null); + + var s = []; + s.push("dispatch exception:"); + s.push("\nidentity: " + this._instance.identityToString(this._current.id)); + s.push("\nfacet: " + StringUtil.escapeString(this._current.facet, "")); + s.push("\noperation: " + this._current.operation); + if(this._connection !== null) + { + var connInfo = this._connection.getInfo(); + if(connInfo instanceof Ice.IPConnectionInfo) + { + var ipConnInfo = connInfo; + s.push("\nremote host: " + ipConnInfo.remoteAddress + " remote port: " + ipConnInfo.remotePort); + } + } + if(ex.stack) + { + s.push("\n"); + s.push(ex.stack); + } + this._instance.initializationData().logger.warning(s.join("")); + }, + __servantLocatorFinished: function() + { + Debug.assert(this._locator !== null && this._servant !== null); + try + { + this._locator.finished(this._current, this._servant, this._cookie.value); + return true; + } + catch(ex) + { + if(ex instanceof Ice.UserException) + { + Debug.assert(this._connection !== null); + + // + // The operation may have already marshaled a reply; we must overwrite that reply. + // + if(this._response) + { + this._os.resize(Protocol.headerSize + 4); // Reply status position. + this._os.writeByte(Protocol.replyUserException); + this._os.startWriteEncaps(); + this._os.writeUserException(ex); + this._os.endWriteEncaps(); + this._connection.sendResponse(this._os, this._compress); + } + else + { + this._connection.sendNoResponse(); + } + + this._connection = null; + } + else + { + this.__handleException(ex); + } + return false; + } + }, + __handleException: function(ex) + { + Debug.assert(this._connection !== null); + + var props = this._instance.initializationData().properties; + var s; + if(ex instanceof Ice.RequestFailedException) + { + if(ex.id === null) + { + ex.id = this._current.id; + } + + if(ex.facet === null) + { + ex.facet = this._current.facet; + } + + if(ex.operation === null || ex.operation.length === 0) + { + ex.operation = this._current.operation; + } + + if(props.getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 1) + { + this.__warning(ex); + } + + if(this._response) + { + this._os.resize(Protocol.headerSize + 4); // Reply status position. + if(ex instanceof Ice.ObjectNotExistException) + { + this._os.writeByte(Protocol.replyObjectNotExist); + } + else if(ex instanceof Ice.FacetNotExistException) + { + this._os.writeByte(Protocol.replyFacetNotExist); + } + else if(ex instanceof Ice.OperationNotExistException) + { + this._os.writeByte(Protocol.replyOperationNotExist); + } + else + { + Debug.assert(false); + } + ex.id.__write(this._os); + + // + // For compatibility with the old FacetPath. + // + if(ex.facet === null || ex.facet.length === 0) + { + Ice.StringSeqHelper.write(this._os, null); + } + else + { + Ice.StringSeqHelper.write(this._os, [ ex.facet ]); + } + + this._os.writeString(ex.operation); + + this._connection.sendResponse(this._os, this._compress); + } + else + { + this._connection.sendNoResponse(); + } + } + else if(ex instanceof Ice.UnknownLocalException) + { + if(props.getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + this.__warning(ex); + } + + if(this._response) + { + this._os.resize(Protocol.headerSize + 4); // Reply status position. + this._os.writeByte(Protocol.replyUnknownLocalException); + this._os.writeString(ex.unknown); + this._connection.sendResponse(this._os, this._compress); + } + else + { + this._connection.sendNoResponse(); + } + } + else if(ex instanceof Ice.UnknownUserException) + { + if(props.getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + this.__warning(ex); + } + + if(this._response) + { + this._os.resize(Protocol.headerSize + 4); // Reply status position. + this._os.writeByte(Protocol.replyUnknownUserException); + this._os.writeString(ex.unknown); + this._connection.sendResponse(this._os, this._compress); + } + else + { + this._connection.sendNoResponse(); + } + } + else if(ex instanceof Ice.UnknownException) + { + if(props.getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + this.__warning(ex); + } + + if(this._response) + { + this._os.resize(Protocol.headerSize + 4); // Reply status position. + this._os.writeByte(Protocol.replyUnknownException); + this._os.writeString(ex.unknown); + this._connection.sendResponse(this._os, this._compress); + } + else + { + this._connection.sendNoResponse(); + } + } + else if(ex instanceof Ice.LocalException) + { + if(props.getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + this.__warning(ex); + } + + if(this._response) + { + this._os.resize(Protocol.headerSize + 4); // Reply status position. + this._os.writeByte(Protocol.replyUnknownLocalException); + //this._os.writeString(ex.toString()); + s = [ ex.ice_name() ]; + if(ex.stack) + { + s.push("\n"); + s.push(ex.stack); + } + this._os.writeString(s.join("")); + this._connection.sendResponse(this._os, this._compress); + } + else + { + this._connection.sendNoResponse(); + } + } + else if(ex instanceof Ice.UserException) + { + if(props.getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + this.__warning(ex); + } + + if(this._response) + { + this._os.resize(Protocol.headerSize + 4); // Reply status position. + this._os.writeByte(Protocol.replyUnknownUserException); + //this._os.writeString(ex.toString()); + s = [ ex.ice_name() ]; + if(ex.stack) + { + s.push("\n"); + s.push(ex.stack); + } + this._os.writeString(s.join("")); + this._connection.sendResponse(this._os, this._compress); + } + else + { + this._connection.sendNoResponse(); + } + } + else + { + if(props.getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + this.__warning(ex); + } + + if(this._response) + { + this._os.resize(Protocol.headerSize + 4); // Reply status position. + this._os.writeByte(Protocol.replyUnknownException); + //this._os.writeString(ex.toString()); + this._os.writeString(ex.stack ? ex.stack : ""); + this._connection.sendResponse(this._os, this._compress); + } + else + { + this._connection.sendNoResponse(); + } + } + + this._connection = null; + }, + invoke: function(servantManager, stream) + { + this._is = stream; + + var start = this._is.pos; + + // + // Read the current. + // + this._current.id.__read(this._is); + + // + // For compatibility with the old FacetPath. + // + var facetPath = Ice.StringSeqHelper.read(this._is); + if(facetPath.length > 0) + { + if(facetPath.length > 1) + { + throw new Ice.MarshalException(); + } + this._current.facet = facetPath[0]; + } + else + { + this._current.facet = ""; + } + + this._current.operation = this._is.readString(); + this._current.mode = Ice.OperationMode.valueOf(this._is.readByte()); + this._current.ctx = new HashMap(); + var sz = this._is.readSize(); + while(sz-- > 0) + { + var first = this._is.readString(); + var second = this._is.readString(); + this._current.ctx.set(first, second); + } + + // + // Don't put the code above into the try block below. Exceptions + // in the code above are considered fatal, and must propagate to + // the caller of this operation. + // + + if(servantManager !== null) + { + this._servant = servantManager.findServant(this._current.id, this._current.facet); + if(this._servant === null) + { + this._locator = servantManager.findServantLocator(this._current.id.category); + if(this._locator === null && this._current.id.category.length > 0) + { + this._locator = servantManager.findServantLocator(""); + } + + if(this._locator !== null) + { + try + { + this._servant = this._locator.locate(this._current, this._cookie); + } + catch(ex) + { + if(ex instanceof Ice.UserException) + { + var encoding = this._is.skipEncaps(); // Required for batch requests. + + if(this._response) + { + this._os.writeByte(Protocol.replyUserException); + this._os.startWriteEncaps(encoding, FormatType.DefaultFormat); + this._os.writeUserException(ex); + this._os.endWriteEncaps(); + this._connection.sendResponse(this._os, this._compress); + } + else + { + this._connection.sendNoResponse(); + } + + this._connection = null; + return; + } + else + { + this._is.skipEncaps(); // Required for batch requests. + this.__handleException(ex); + return; + } + } + } + } + } + + try + { + if(this._servant !== null) + { + // + // DispatchAsync is a "pseudo dispatch status", used internally only + // to indicate async dispatch. + // + if(this._servant.__dispatch(this, this._current) === Ice.DispatchStatus.DispatchAsync) + { + // + // If this was an asynchronous dispatch, we're done here. + // + return; + } + + if(this._locator !== null && !this.__servantLocatorFinished()) + { + return; + } + } + else + { + // + // Skip the input parameters, this is required for reading + // the next batch request if dispatching batch requests. + // + this._is.skipEncaps(); + + if(servantManager !== null && servantManager.hasServant(this._current.id)) + { + throw new Ice.FacetNotExistException(this._current.id, this._current.facet, + this._current.operation); + } + else + { + throw new Ice.ObjectNotExistException(this._current.id, this._current.facet, + this._current.operation); + } + } + } + catch(ex) + { + if(this._servant !== null && this._locator !== null && !this.__servantLocatorFinished()) + { + return; + } + this.__handleException(ex); + return; + } + + // + // Don't put the code below into the try block above. Exceptions + // in the code below are considered fatal, and must propagate to + // the caller of this operation. + // + + Debug.assert(this._connection !== null); + + if(this._response) + { + this._connection.sendResponse(this._os, this._compress); + } + else + { + this._connection.sendNoResponse(); + } + + this._connection = null; + }, + startReadParams: function() + { + // + // Remember the encoding used by the input parameters, we'll + // encode the response parameters with the same encoding. + // + this._current.encoding = this._is.startReadEncaps(); + return this._is; + }, + endReadParams: function() + { + this._is.endReadEncaps(); + }, + readEmptyParams: function() + { + this._current.encoding = new Ice.EncodingVersion(); + this._is.skipEmptyEncaps(this._current.encoding); + }, + readParamEncaps: function() + { + this._current.encoding = new Ice.EncodingVersion(); + return this._is.readEncaps(this._current.encoding); + }, + __response: function() + { + try + { + if(this._locator !== null && !this.__servantLocatorFinished()) + { + return; + } + + Debug.assert(this._connection !== null); + + if(this._response) + { + this._connection.sendResponse(this._os, this._compress); + } + else + { + this._connection.sendNoResponse(); + } + + this._connection = null; + } + catch(ex) + { + this._connection.invokeException(ex, 1); + } + }, + __exception: function(exc) + { + try + { + if(this._locator !== null && !this.__servantLocatorFinished()) + { + return; + } + + this.__handleException(exc); + } + catch(ex) + { + this._connection.invokeException(ex, 1); + } + }, + __validateResponse: function(ok) + { + if(!this._active) + { + return false; + } + this._active = false; + return true; + }, + ice_exception: function(ex) + { + if(!this._active) + { + return; + } + this._active = false; + + if(this._connection !== null) + { + this.__exception(ex); + } + else + { + // + // Response has already been sent. + // + if(this._instance.initializationData().properties.getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + this.__warning(ex); + } + } + } + }); + + Ice.IncomingAsync = IncomingAsync; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Initialize.js b/js/src/Ice/Initialize.js new file mode 100644 index 00000000000..e1dd0c4a2b1 --- /dev/null +++ b/js/src/Ice/Initialize.js @@ -0,0 +1,104 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Protocol"); + require("Ice/LocalException"); + require("Ice/Communicator"); + require("Ice/Properties"); + + var Ice = global.Ice || {}; + var Protocol = Ice.Protocol; + + // + // Ice.InitializationData + // + Ice.InitializationData = function() + { + this.properties = null; + this.logger = null; + }; + + Ice.InitializationData.prototype.clone = function() + { + var r = new Ice.InitializationData(); + r.properties = this.properties; + r.logger = this.logger; + return r; + }; + + // + // Ice.initialize() + // + Ice.initialize = function(arg1, arg2) + { + var args = null; + var initData = null; + + if(arg1 instanceof Array) + { + args = arg1; + } + else if(arg1 instanceof Ice.InitializationData) + { + initData = arg1; + } + else if(arg1 !== undefined && arg1 !== null) + { + throw new Ice.InitializationException("invalid argument to initialize"); + } + + if(arg2 !== undefined && arg2 !== null) + { + if(arg2 instanceof Ice.InitializationData && initData === null) + { + initData = arg2; + } + else + { + throw new Ice.InitializationException("invalid argument to initialize"); + } + + } + + if(initData === null) + { + initData = new Ice.InitializationData(); + } + else + { + initData = initData.clone(); + } + initData.properties = Ice.createProperties(args, initData.properties); + + var result = new Ice.Communicator(initData); + result.finishSetup(null); + return result; + }; + + // + // Ice.createProperties() + // + Ice.createProperties = function(args, defaults) + { + return new Ice.Properties(args, defaults); + }; + + Ice.currentProtocol = function() + { + return Protocol.currentProtocol.clone(); + }; + + Ice.currentEncoding = function() + { + return Protocol.currentEncoding.clone(); + }; + + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Instance.js b/js/src/Ice/Instance.js new file mode 100644 index 00000000000..92ba88894d7 --- /dev/null +++ b/js/src/Ice/Instance.js @@ -0,0 +1,573 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/AsyncResultBase"); + require("Ice/ConnectionMonitor"); + require("Ice/Debug"); + require("Ice/DefaultsAndOverrides"); + require("Ice/EndpointFactoryManager"); + require("Ice/HashMap"); + require("Ice/ImplicitContextI"); + require("Ice/IdentityUtil"); + require("Ice/LocatorManager"); + require("Ice/Logger"); + require("Ice/ObjectAdapterFactory"); + require("Ice/ObjectFactoryManager"); + require("Ice/OutgoingConnectionFactory"); + require("Ice/Promise"); + require("Ice/Properties"); + require("Ice/ProxyFactory"); + require("Ice/RetryQueue"); + require("Ice/RouterManager"); + require("Ice/Timer"); + require("Ice/TraceLevels"); + require("Ice/Reference"); + require("Ice/LocalException"); + require("Ice/Exception"); + require("Ice/ProcessLogger"); + + // + // We don't load the endpoint factories here, instead the Ice.js + // file for NodeJS loads the TcpEndpointFactory and the Ice.js + // file for the web browser includes the IceWS endpoint factory. + // + //require("Ice/TcpEndpointFactory"); + //require("IceWS/EndpointFactory"); + + var Ice = global.Ice || {}; + + var AsyncResultBase = Ice.AsyncResultBase; + var ConnectionMonitor = Ice.ConnectionMonitor; + var Debug = Ice.Debug; + var DefaultsAndOverrides = Ice.DefaultsAndOverrides; + var EndpointFactoryManager = Ice.EndpointFactoryManager; + var HashMap = Ice.HashMap; + var ImplicitContextI = Ice.ImplicitContextI; + var LocatorManager = Ice.LocatorManager; + var Logger = Ice.Logger; + var ObjectAdapterFactory = Ice.ObjectAdapterFactory; + var ObjectFactoryManager = Ice.ObjectFactoryManager; + var OutgoingConnectionFactory = Ice.OutgoingConnectionFactory; + var Promise = Ice.Promise; + var Properties = Ice.Properties; + var ProxyFactory = Ice.ProxyFactory; + var RetryQueue = Ice.RetryQueue; + var RouterManager = Ice.RouterManager; + var Timer = Ice.Timer; + var TraceLevels = Ice.TraceLevels; + var ReferenceFactory = Ice.ReferenceFactory; + + var StateActive = 0; + var StateDestroyInProgress = 1; + var StateDestroyed = 2; + + // + // Instance - only for use by Communicator + // + var Instance = Ice.Class({ + __init__: function(initData) + { + this._state = StateActive; + this._initData = initData; + + this._traceLevels = null; + this._defaultsAndOverrides = null; + this._messageSizeMax = null; + this._clientACM = null; + this._serverACM = null; + this._implicitContext = null; + this._routerManager = null; + this._locatorManager = null; + this._referenceFactory = null; + this._proxyFactory = null; + this._outgoingConnectionFactory = null; + this._connectionMonitor = null; + this._servantFactoryManager = null; + this._objectAdapterFactory = null; + this._protocolSupport = null; + this._retryQueue = null; + this._endpointHostResolver = null; + this._endpointFactoryManager = null; + }, + initializationData: function() + { + // + // No check for destruction. It must be possible to access the + // initialization data after destruction. + // + // This value is immutable. + // + return this._initData; + }, + traceLevels: function() + { + // This value is immutable. + Debug.assert(this._traceLevels !== null); + return this._traceLevels; + }, + defaultsAndOverrides: function() + { + // This value is immutable. + Debug.assert(this._defaultsAndOverrides !== null); + return this._defaultsAndOverrides; + }, + routerManager: function() + { + if(this._state === StateDestroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + Debug.assert(this._routerManager !== null); + return this._routerManager; + }, + locatorManager: function() + { + if(this._state === StateDestroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + Debug.assert(this._locatorManager !== null); + return this._locatorManager; + }, + referenceFactory: function() + { + if(this._state === StateDestroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + Debug.assert(this._referenceFactory !== null); + return this._referenceFactory; + }, + proxyFactory: function() + { + if(this._state === StateDestroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + Debug.assert(this._proxyFactory !== null); + return this._proxyFactory; + }, + outgoingConnectionFactory: function() + { + if(this._state === StateDestroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + Debug.assert(this._outgoingConnectionFactory !== null); + return this._outgoingConnectionFactory; + }, + preferIPv6: function() + { + return this._preferIPv6; + }, + connectionMonitor: function() + { + if(this._state === StateDestroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + Debug.assert(this._connectionMonitor !== null); + return this._connectionMonitor; + }, + servantFactoryManager: function() + { + if(this._state === StateDestroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + Debug.assert(this._servantFactoryManager !== null); + return this._servantFactoryManager; + }, + objectAdapterFactory: function() + { + if(this._state === StateDestroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + Debug.assert(this._objectAdapterFactory !== null); + return this._objectAdapterFactory; + }, + protocolSupport: function() + { + if(this._state == StateDestroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + return this._protocolSupport; + }, + retryQueue: function() + { + if(this._state === StateDestroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + Debug.assert(this._retryQueue !== null); + return this._retryQueue; + }, + timer: function() + { + if(this._state === StateDestroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + Debug.assert(this._timer !== null); + return this._timer; + }, + endpointFactoryManager: function() + { + if(this._state === StateDestroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + Debug.assert(this._endpointFactoryManager !== null); + return this._endpointFactoryManager; + }, + messageSizeMax: function() + { + // This value is immutable. + return this._messageSizeMax; + }, + clientACM: function() + { + // This value is immutable. + return this._clientACM; + }, + serverACM: function() + { + // This value is immutable. + return this._serverACM; + }, + getImplicitContext: function() + { + return this._implicitContext; + }, + stringToIdentity: function(s) + { + return Ice.stringToIdentity(s); + }, + identityToString: function(ident) + { + return Ice.identityToString(ident); + }, + + setDefaultLocator: function(locator) + { + if(this._state == StateDestroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + this._referenceFactory = this._referenceFactory.setDefaultLocator(locator); + }, + setDefaultRouter: function(router) + { + if(this._state == StateDestroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + this._referenceFactory = this._referenceFactory.setDefaultRouter(router); + }, + setLogger: function(logger) + { + this._initData.logger = logger; + }, + finishSetup: function(communicator, promise) + { + // + // If promise == null, it means the caller is requesting a synchronous setup. + // Otherwise, we resolve the promise after all initialization is complete. + // + + try + { + this._timer = new Timer(); + + if(this._initData.properties === null) + { + this._initData.properties = Properties.createProperties(); + } + + if(this._initData.logger === null) + { + this._initData.logger = Ice.getProcessLogger(); + } + + this._traceLevels = new TraceLevels(this._initData.properties); + + this._defaultsAndOverrides = new DefaultsAndOverrides(this._initData.properties); + + var defMessageSizeMax = 1024; + var num = this._initData.properties.getPropertyAsIntWithDefault("Ice.MessageSizeMax", defMessageSizeMax); + if(num < 1) + { + this._messageSizeMax = defMessageSizeMax * 1024; // Ignore non-sensical values. + } + else if(num > 0x7fffffff / 1024) + { + this._messageSizeMax = 0x7fffffff; + } + else + { + this._messageSizeMax = num * 1024; // Property is in kilobytes, _messageSizeMax in bytes + } + + // + // Client ACM enabled by default. Server ACM disabled by default. + // + this._clientACM = this._initData.properties.getPropertyAsIntWithDefault("Ice.ACM.Client", 60); + this._serverACM = this._initData.properties.getPropertyAsInt("Ice.ACM.Server"); + + this._implicitContext = ImplicitContextI.create(this._initData.properties.getProperty("Ice.ImplicitContext")); + + this._routerManager = new RouterManager(); + + this._locatorManager = new LocatorManager(this._initData.properties); + + this._referenceFactory = new ReferenceFactory(this, communicator); + + this._proxyFactory = new ProxyFactory(this); + + this._endpointFactoryManager = new EndpointFactoryManager(this); + + if(typeof(Ice.TcpEndpointFactory) !== "undefined") + { + this._endpointFactoryManager.add(new Ice.TcpEndpointFactory(this)); + } + + if(typeof(IceWS) !== "undefined" && typeof(IceWS.EndpointFactory) !== "undefined") + { + this._endpointFactoryManager.add(new IceWS.EndpointFactory(this, false)); + this._endpointFactoryManager.add(new IceWS.EndpointFactory(this, true)); + } + + this._outgoingConnectionFactory = new OutgoingConnectionFactory(communicator, this); + this._servantFactoryManager = new ObjectFactoryManager(); + + this._objectAdapterFactory = new ObjectAdapterFactory(this, communicator); + + this._retryQueue = new RetryQueue(this); + + // + // Get default router and locator proxies. Don't move this + // initialization before the plug-in initialization!!! The proxies + // might depend on endpoint factories to be installed by plug-ins. + // + var router = Ice.RouterPrx.uncheckedCast(this._proxyFactory.propertyToProxy("Ice.Default.Router")); + if(router !== null) + { + this._referenceFactory = this._referenceFactory.setDefaultRouter(router); + } + + var loc = Ice.LocatorPrx.uncheckedCast(this._proxyFactory.propertyToProxy("Ice.Default.Locator")); + if(loc !== null) + { + this._referenceFactory = this._referenceFactory.setDefaultLocator(loc); + } + + // + // Create the connection monitor and ensure the interval for + // monitoring connections is appropriate for client & server + // ACM. + // + var interval = this._initData.properties.getPropertyAsInt("Ice.MonitorConnections"); + this._connectionMonitor = new ConnectionMonitor(this, interval); + this._connectionMonitor.checkIntervalForACM(this._clientACM); + this._connectionMonitor.checkIntervalForACM(this._serverACM); + + if(promise !== null) + { + promise.succeed(communicator); + } + } + catch(ex) + { + if(promise !== null) + { + if(ex instanceof Ice.LocalException) + { + this.destroy().finally(function() + { + promise.fail(ex); + }); + } + else + { + promise.fail(ex); + } + } + else + { + if(ex instanceof Ice.LocalException) + { + this.destroy(); + } + throw ex; + } + } + }, + // + // Only for use by Ice.CommunicatorI + // + destroy: function() + { + var promise = new AsyncResultBase(null, "destroy", null, this, null); + + // + // If the _state is not StateActive then the instance is + // either being destroyed, or has already been destroyed. + // + if(this._state != StateActive) + { + promise.succeed(promise); + return promise; + } + + // + // We cannot set state to StateDestroyed otherwise instance + // methods called during the destroy process (such as + // outgoingConnectionFactory() from + // ObjectAdapterI::deactivate() will cause an exception. + // + this._state = StateDestroyInProgress; + + var self = this; + Ice.Promise.try( + function() + { + if(self._objectAdapterFactory) + { + return self._objectAdapterFactory.shutdown(); + } + } + ).then( + function() + { + if(self._outgoingConnectionFactory !== null) + { + self._outgoingConnectionFactory.destroy(); + } + + if(self._objectAdapterFactory !== null) + { + return self._objectAdapterFactory.destroy(); + } + } + ).then( + function() + { + if(self._outgoingConnectionFactory !== null) + { + return self._outgoingConnectionFactory.waitUntilFinished(); + } + } + ).then( + function() + { + if(self._retryQueue) + { + self._retryQueue.destroy(); + } + + self._objectAdapterFactory = null; + self._outgoingConnectionFactory = null; + self._retryQueue = null; + + if(self._connectionMonitor) + { + self._connectionMonitor.destroy(); + self._connectionMonitor = null; + } + + if(self._timer) + { + self._timer.destroy(); + self._timer = null; + } + + if(self._servantFactoryManager) + { + self._servantFactoryManager.destroy(); + self._servantFactoryManager = null; + } + + if(self._referenceFactory) + { + //self._referenceFactory.destroy(); // No destroy function defined. + self._referenceFactory = null; + } + + // self._proxyFactory.destroy(); // No destroy function defined. + self._proxyFactory = null; + + if(self._routerManager) + { + self._routerManager.destroy(); + self._routerManager = null; + } + + if(self._locatorManager) + { + self._locatorManager.destroy(); + self._locatorManager = null; + } + + if(self._endpointFactoryManager) + { + self._endpointFactoryManager.destroy(); + self._endpointFactoryManager = null; + } + + self._state = StateDestroyed; + + if(self._initData.properties.getPropertyAsInt("Ice.Warn.UnusedProperties") > 0) + { + var unusedProperties = self._initData.properties.getUnusedProperties(); + if(unusedProperties.length > 0) + { + var message = []; + message.push("The following properties were set but never read:"); + for(var i = 0; i < unusedProperties.length; ++i) + { + message.push("\n "); + message.push(unusedProperties[i]); + } + self._initData.logger.warning(message.join("")); + } + } + + promise.succeed(promise); + } + ).exception( + function(ex) + { + promise.fail(ex); + } + ); + return promise; + }, + }); + + Ice.Instance = Instance; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/LocalExceptionWrapper.js b/js/src/Ice/LocalExceptionWrapper.js new file mode 100644 index 00000000000..993858b8e7c --- /dev/null +++ b/js/src/Ice/LocalExceptionWrapper.js @@ -0,0 +1,83 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Exception"); + require("Ice/ExUtil"); + require("Ice/Debug"); + require("Ice/LocalException"); + + var Ice = global.Ice || {}; + + var ExUtil = Ice.ExUtil; + var Debug = Ice.Debug; + + var LocalExceptionWrapper = Ice.Class(Error, { + __init__: function(ex, retry) + { + retry = retry === undefined ? false : retry; + + if(ex instanceof Ice.LocalException) + { + this._ex = ex; + this._retry = retry; + } + else + { + Debug.assert(ex instanceof LocalExceptionWrapper); + this._ex = ex._ex; + this._retry = ex._retry; + } + } + }); + + LocalExceptionWrapper.throwWrapper = function(ex) + { + if(ex instanceof Ice.UserException) + { + throw new LocalExceptionWrapper(new Ice.UnknownUserException(ex.ice_name()), false); + } + else if(ex instanceof Ice.LocalException) + { + if(ex instanceof Ice.UnknownException || + ex instanceof Ice.ObjectNotExistException || + ex instanceof Ice.OperationNotExistException || + ex instanceof Ice.FacetNotExistException) + { + throw new LocalExceptionWrapper(ex, false); + } + var e = new Ice.UnknownLocalException(ex.ice_name(), ex); + throw new LocalExceptionWrapper(e, false); + } + + var ue = new Ice.UnknownException(ExUtil.toString(ex), ex); + throw new LocalExceptionWrapper(ue, false); + }; + + var prototype = LocalExceptionWrapper.prototype; + + Object.defineProperty(prototype, "inner", { + get: function() { return this._ex; } + }); + + // + // If true, always repeat the request. Don't take retry settings + // or "at-most-once" guarantees into account. + // + // If false, only repeat the request if the retry settings allow + // to do so, and if "at-most-once" does not need to be guaranteed. + // + Object.defineProperty(prototype, "retry", { + get: function() { return this._retry; } + }); + + Ice.LocalExceptionWrapper = LocalExceptionWrapper; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/LocatorInfo.js b/js/src/Ice/LocatorInfo.js new file mode 100644 index 00000000000..9b255978463 --- /dev/null +++ b/js/src/Ice/LocatorInfo.js @@ -0,0 +1,608 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Debug"); + require("Ice/ExUtil"); + require("Ice/HashMap"); + require("Ice/Promise"); + require("Ice/Protocol"); + require("Ice/Locator"); + require("Ice/LocalException"); + require("Ice/Exception"); + + var Ice = global.Ice || {}; + + var Debug = Ice.Debug; + var ExUtil = Ice.ExUtil; + var HashMap = Ice.HashMap; + var Promise = Ice.Promise; + var Protocol = Ice.Protocol; + var LocatorRegistryPrx = Ice.LocatorRegisterPrx; + + var Class = Ice.Class; + + var LocatorInfo = Class({ + __init__: function(locator, table, background) + { + this._locator = locator; + this._locatorRegistry = null; + this._table = table; + this._background = background; + + this._adapterRequests = new HashMap(); // Map<String, Request> + this._objectRequests = new HashMap(); // Map<Ice.Identity, Request> + this._objectRequests.keyComparator = HashMap.compareEquals; + }, + destroy: function() + { + this._locatorRegistry = null; + this._table.clear(); + }, + equals: function(rhs) + { + if(this === rhs) + { + return true; + } + + if(rhs instanceof LocatorInfo) + { + return this._locator.equals(rhs._locator); + } + + return false; + }, + hashCode: function() + { + return this._locator.hashCode(); + }, + getLocator: function() + { + return this._locator; + }, + getLocatorRegistry: function() + { + if(this._locatorRegistry !== null) + { + return new Promise().succeed(this._locatorRegistry); + } + + var self = this; + return this._locator.getRegistry().then( + function(reg) + { + // + // The locator registry can't be located. + // + self._locatorRegistry = LocatorRegistryPrx.uncheckedCast(reg.ice_locator(null)); + return self._locatorRegistry; + }); + }, + getEndpoints: function(ref, wellKnownRef, ttl, p) + { + var promise = p || new Promise(); // success callback receives (endpoints, cached) + + Debug.assert(ref.isIndirect()); + var endpoints = null; + var cached = { value: false }; + if(!ref.isWellKnown()) + { + endpoints = this._table.getAdapterEndpoints(ref.getAdapterId(), ttl, cached); + if(!cached.value) + { + if(this._background && endpoints !== null) + { + this.getAdapterRequest(ref).addCallback(ref, wellKnownRef, ttl, null); + } + else + { + this.getAdapterRequest(ref).addCallback(ref, wellKnownRef, ttl, promise); + return promise; + } + } + } + else + { + var r = this._table.getObjectReference(ref.getIdentity(), ttl, cached); + if(!cached.value) + { + if(this._background && r !== null) + { + this.getObjectRequest(ref).addCallback(ref, null, ttl, null); + } + else + { + this.getObjectRequest(ref).addCallback(ref, null, ttl, promise); + return promise; + } + } + + if(!r.isIndirect()) + { + endpoints = r.getEndpoints(); + } + else if(!r.isWellKnown()) + { + this.getEndpoints(r, ref, ttl, promise); + return promise; + } + } + + Debug.assert(endpoints !== null); + if(ref.getInstance().traceLevels().location >= 1) + { + this.getEndpointsTrace(ref, endpoints, true); + } + promise.succeed(endpoints, true); + + return promise; + }, + clearCache: function(ref) + { + Debug.assert(ref.isIndirect()); + + if(!ref.isWellKnown()) + { + var endpoints = this._table.removeAdapterEndpoints(ref.getAdapterId()); + + if(endpoints !== null && ref.getInstance().traceLevels().location >= 2) + { + this.trace("removed endpoints from locator table\n", ref, endpoints); + } + } + else + { + var r = this._table.removeObjectReference(ref.getIdentity()); + if(r !== null) + { + if(!r.isIndirect()) + { + if(ref.getInstance().traceLevels().location >= 2) + { + this.trace("removed endpoints from locator table", ref, r.getEndpoints()); + } + } + else if(!r.isWellKnown()) + { + this.clearCache(r); + } + } + } + }, + trace: function(msg, ref, endpoints) + { + Debug.assert(ref.isIndirect()); + + var s = []; + s.push(msg); + s.push("\n"); + if(!ref.isWellKnown()) + { + s.push("adapter = "); + s.push(ref.getAdapterId()); + s.push("\n"); + } + else + { + s.push("object = "); + s.push(ref.getInstance().identityToString(ref.getIdentity())); + s.push("\n"); + } + + s.push("endpoints = "); + for(var i = 0; i < endpoints.length; i++) + { + s.push(endpoints[i].toString()); + if(i + 1 < endpoints.length) + { + s.push(":"); + } + } + + ref.getInstance().initializationData().logger.trace(ref.getInstance().traceLevels().locationCat, s.join("")); + }, + getEndpointsException: function(ref, exc) + { + Debug.assert(ref.isIndirect()); + + var instance = ref.getInstance(); + var s, e; + try + { + throw exc; + } + catch(ex) + { + if(ex instanceof Ice.AdapterNotFoundException) + { + if(instance.traceLevels().location >= 1) + { + s = []; + s.push("adapter not found\n"); + s.push("adapter = "); + s.push(ref.getAdapterId()); + instance.initializationData().logger.trace(instance.traceLevels().locationCat, s.join("")); + } + + e = new Ice.NotRegisteredException(); + e.kindOfObject = "object adapter"; + e.id = ref.getAdapterId(); + throw e; + } + else if(ex instanceof Ice.ObjectNotFoundException) + { + if(instance.traceLevels().location >= 1) + { + s = []; + s.push("object not found\n"); + s.push("object = "); + s.push(instance.identityToString(ref.getIdentity())); + instance.initializationData().logger.trace(instance.traceLevels().locationCat, s.join("")); + } + + e = new Ice.NotRegisteredException(); + e.kindOfObject = "object"; + e.id = instance.identityToString(ref.getIdentity()); + throw e; + } + else if(ex instanceof Ice.NotRegisteredException) + { + throw ex; + } + else if(ex instanceof Ice.LocalException) + { + if(instance.traceLevels().location >= 1) + { + s = []; + s.push("couldn't contact the locator to retrieve adapter endpoints\n"); + if(ref.getAdapterId().length > 0) + { + s.push("adapter = "); + s.push(ref.getAdapterId()); + s.push("\n"); + } + else + { + s.push("object = "); + s.push(instance.identityToString(ref.getIdentity())); + s.push("\n"); + } + s.push("reason = " + ExUtil.toString(ex)); + instance.initializationData().logger.trace(instance.traceLevels().locationCat, s.join("")); + } + throw ex; + } + else + { + Debug.assert(false); + } + } + }, + getEndpointsTrace: function(ref, endpoints, cached) + { + if(endpoints !== null && endpoints.length > 0) + { + if(cached) + { + this.trace("found endpoints in locator table", ref, endpoints); + } + else + { + this.trace("retrieved endpoints from locator, adding to locator table", ref, endpoints); + } + } + else + { + var instance = ref.getInstance(); + var s = []; + s.push("no endpoints configured for "); + if(ref.getAdapterId().length > 0) + { + s.push("adapter\n"); + s.push("adapter = "); + s.push(ref.getAdapterId()); + s.push("\n"); + } + else + { + s.push("object\n"); + s.push("object = "); + s.push(instance.identityToString(ref.getIdentity())); + s.push("\n"); + } + instance.initializationData().logger.trace(instance.traceLevels().locationCat, s.join("")); + } + }, + getAdapterRequest: function(ref) + { + if(ref.getInstance().traceLevels().location >= 1) + { + var instance = ref.getInstance(); + var s = []; + s.push("searching for adapter by id\n"); + s.push("adapter = "); + s.push(ref.getAdapterId()); + instance.initializationData().logger.trace(instance.traceLevels().locationCat, s.join("")); + } + + var request = this._adapterRequests.get(ref.getAdapterId()); + if(request !== undefined) + { + return request; + } + request = new AdapterRequest(this, ref); + this._adapterRequests.set(ref.getAdapterId(), request); + return request; + }, + getObjectRequest: function(ref) + { + if(ref.getInstance().traceLevels().location >= 1) + { + var instance = ref.getInstance(); + var s = []; + s.push("searching for object by id\n"); + s.push("object = "); + s.push(instance.identityToString(ref.getIdentity())); + instance.initializationData().logger.trace(instance.traceLevels().locationCat, s.join("")); + } + + var request = this._objectRequests.get(ref.getIdentity()); + if(request !== undefined) + { + return request; + } + request = new ObjectRequest(this, ref); + this._objectRequests.set(ref.getIdentity(), request); + return request; + }, + finishRequest: function(ref, wellKnownRefs, proxy, notRegistered) + { + if(proxy === null || proxy.__reference().isIndirect()) + { + // + // Remove the cached references of well-known objects for which we tried + // to resolved the endpoints if these endpoints are empty. + // + for(var i = 0; i < wellKnownRefs.length; ++i) + { + this._table.removeObjectReference(wellKnownRefs[i].getIdentity()); + } + } + + if(!ref.isWellKnown()) + { + if(proxy !== null && !proxy.__reference().isIndirect()) + { + // Cache the adapter endpoints. + this._table.addAdapterEndpoints(ref.getAdapterId(), proxy.__reference().getEndpoints()); + } + else if(notRegistered) // If the adapter isn't registered anymore, remove it from the cache. + { + this._table.removeAdapterEndpoints(ref.getAdapterId()); + } + + Debug.assert(this._adapterRequests.has(ref.getAdapterId())); + this._adapterRequests.delete(ref.getAdapterId()); + } + else + { + if(proxy !== null && !proxy.__reference().isWellKnown()) + { + // Cache the well-known object reference. + this._table.addObjectReference(ref.getIdentity(), proxy.__reference()); + } + else if(notRegistered) // If the well-known object isn't registered anymore, remove it from the cache. + { + this._table.removeObjectReference(ref.getIdentity()); + } + + Debug.assert(this._objectRequests.has(ref.getIdentity())); + this._objectRequests.delete(ref.getIdentity()); + } + } + }); + + Ice.LocatorInfo = LocatorInfo; + global.Ice = Ice; + + var RequestCallback = Class({ + __init__: function(ref, ttl, promise) + { + this._ref = ref; + this._ttl = ttl; + this._promise = promise; + }, + response: function(locatorInfo, proxy) + { + var endpoints = null; + if(proxy !== null) + { + var r = proxy.__reference(); + if(this._ref.isWellKnown() && !Protocol.isSupported(this._ref.getEncoding(), r.getEncoding())) + { + // + // If a well-known proxy and the returned proxy + // encoding isn't supported, we're done: there's + // no compatible endpoint we can use. + // + } + else if(!r.isIndirect()) + { + endpoints = r.getEndpoints(); + } + else if(this._ref.isWellKnown() && !r.isWellKnown()) + { + // + // We're resolving the endpoints of a well-known object and the proxy returned + // by the locator is an indirect proxy. We now need to resolve the endpoints + // of this indirect proxy. + // + var self = this; + locatorInfo.getEndpoints(r, this._ref, this._ttl).then( + function(endpts, b) + { + if(self._promise !== null) + { + self._promise.succeed(endpts, b); + } + }, + function(ex) + { + if(self._promise !== null) + { + self._promise.fail(ex); + } + }); + return; + } + } + + if(this._ref.getInstance().traceLevels().location >= 1) + { + locatorInfo.getEndpointsTrace(this._ref, endpoints, false); + } + + if(this._promise !== null) + { + this._promise.succeed(endpoints === null ? [] : endpoints, false); + } + }, + exception: function(locatorInfo, exc) + { + try + { + locatorInfo.getEndpointsException(this._ref, exc); // This throws. + } + catch(ex) + { + if(this._promise !== null) + { + this._promise.fail(ex); + } + } + } + }); + + var Request = Class({ + __init__: function(locatorInfo, ref) + { + this._locatorInfo = locatorInfo; + this._ref = ref; + + this._callbacks = []; // Array<RequestCallback> + this._wellKnownRefs = []; // Array<Reference> + this._sent = false; + this._response = false; + this._proxy = null; + this._exception = null; + }, + addCallback: function(ref, wellKnownRef, ttl, promise) + { + var callback = new RequestCallback(ref, ttl, promise); + if(this._response) + { + callback.response(this._locatorInfo, this._proxy); + } + else if(this._exception !== null) + { + callback.exception(this._locatorInfo, this._exception); + } + else + { + this._callbacks.push(callback); + if(wellKnownRef !== null) // This request is to resolve the endpoints of a cached well-known object ref + { + this._wellKnownRefs.push(wellKnownRef); + } + if(!this._sent) + { + this._sent = true; + this.send(); + } + } + }, + response: function(proxy) + { + this._locatorInfo.finishRequest(this._ref, this._wellKnownRefs, proxy, false); + this._response = true; + this._proxy = proxy; + for(var i = 0; i < this._callbacks.length; ++i) + { + this._callbacks[i].response(this._locatorInfo, proxy); + } + }, + exception: function(ex) + { + this._locatorInfo.finishRequest(this._ref, this._wellKnownRefs, null, ex instanceof Ice.UserException); + this._exception = ex; + for(var i = 0; i < this._callbacks.length; ++i) + { + this._callbacks[i].exception(this._locatorInfo, ex); + } + } + }); + + var ObjectRequest = Class(Request, { + __init__: function(locatorInfo, reference) + { + Request.call(this, locatorInfo, reference); + Debug.assert(reference.isWellKnown()); + }, + send: function() + { + try + { + var self = this; + this._locatorInfo.getLocator().findObjectById(this._ref.getIdentity()).then( + function(proxy) + { + self.response(proxy); + }, + function(ex) + { + self.exception(ex); + }); + } + catch(ex) + { + this.exception(ex); + } + } + }); + + var AdapterRequest = Class(Request, { + __init__: function(locatorInfo, reference) + { + Request.call(this, locatorInfo, reference); + Debug.assert(reference.isIndirect()); + }, + send: function() + { + try + { + var self = this; + this._locatorInfo.getLocator().findAdapterById(this._ref.getAdapterId()).then( + function(proxy) + { + self.response(proxy); + }, + function(ex) + { + self.exception(ex); + }); + } + catch(ex) + { + this.exception(ex); + } + } + }); +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/LocatorManager.js b/js/src/Ice/LocatorManager.js new file mode 100644 index 00000000000..e7389b844af --- /dev/null +++ b/js/src/Ice/LocatorManager.js @@ -0,0 +1,88 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/HashMap"); + require("Ice/LocatorInfo"); + require("Ice/LocatorTable"); + require("Ice/Locator"); + + var Ice = global.Ice || {}; + + var HashMap = Ice.HashMap; + var LocatorInfo = Ice.LocatorInfo; + var LocatorTable = Ice.LocatorTable; + var LocatorPrx = Ice.LocatorPrx; + + var LocatorManager = Ice.Class({ + __init__: function(properties) + { + this._background = properties.getPropertyAsInt("Ice.BackgroundLocatorCacheUpdates") > 0; + + this._table = new HashMap(); // Map<Ice.LocatorPrx, LocatorInfo> + this._table.keyComparator = HashMap.compareEquals; + this._locatorTables = new HashMap(); // Map<Ice.Identity, LocatorTable> + this._locatorTables.keyComparator = HashMap.compareEquals; + }, + destroy: function() + { + for(var e = this._table.entries; e !== null; e = e.next) + { + e.value.destroy(); + } + this._table.clear(); + this._locatorTables.clear(); + }, + // + // Returns locator info for a given locator. Automatically creates + // the locator info if it doesn't exist yet. + // + find: function(loc) + { + if(loc === null) + { + return null; + } + + // + // The locator can't be located. + // + var locator = LocatorPrx.uncheckedCast(loc.ice_locator(null)); + + // + // TODO: reap unused locator info objects? + // + + var info = this._table.get(locator); + if(info === undefined) + { + // + // Rely on locator identity for the adapter table. We want to + // have only one table per locator (not one per locator + // proxy). + // + var table = this._locatorTables.get(locator.ice_getIdentity()); + if(table === undefined) + { + table = new LocatorTable(); + this._locatorTables.set(locator.ice_getIdentity(), table); + } + + info = new LocatorInfo(locator, table, this._background); + this._table.set(locator, info); + } + + return info; + } + }); + + Ice.LocatorManager = LocatorManager; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/LocatorTable.js b/js/src/Ice/LocatorTable.js new file mode 100644 index 00000000000..e80465b5be9 --- /dev/null +++ b/js/src/Ice/LocatorTable.js @@ -0,0 +1,114 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/HashMap"); + require("Ice/Debug"); + + var Ice = global.Ice || {}; + + var HashMap = Ice.HashMap; + var Debug = Ice.Debug; + + var LocatorTable = Ice.Class({ + __init__: function() + { + this._adapterEndpointsTable = new HashMap(); // Map<String, EndpointTableEntry> + this._objectTable = new HashMap(); // Map<Ice.Identity, ReferenceTableEntry> + this._objectTable.keyComparator = HashMap.compareEquals; + }, + clear: function() + { + this._adapterEndpointsTable.clear(); + this._objectTable.clear(); + }, + getAdapterEndpoints: function(adapter, ttl, cached) + { + if(ttl === 0) // Locator cache disabled. + { + cached.value = false; + return null; + } + + var entry = this._adapterEndpointsTable.get(adapter); + if(entry !== undefined) + { + cached.value = this.checkTTL(entry.time, ttl); + return entry.endpoints; + } + cached.value = false; + return null; + }, + addAdapterEndpoints: function(adapter, endpoints) + { + this._adapterEndpointsTable.set(adapter, new EndpointTableEntry(Date.now(), endpoints)); + }, + removeAdapterEndpoints: function(adapter) + { + var entry = this._adapterEndpointsTable.get(adapter); + this._adapterEndpointsTable.delete(adapter); + return entry !== undefined ? entry.endpoints : null; + }, + getObjectReference: function(id, ttl, cached) + { + if(ttl === 0) // Locator cache disabled. + { + cached.value = false; + return null; + } + + var entry = this._objectTable.get(id); + if(entry !== undefined) + { + cached.value = this.checkTTL(entry.time, ttl); + return entry.reference; + } + cached.value = false; + return null; + }, + addObjectReference: function(id, ref) + { + this._objectTable.set(id, new ReferenceTableEntry(Date.now(), ref)); + }, + removeObjectReference: function(id) + { + var entry = this._objectTable.get(id); + this._objectTable.delete(id); + return entry !== undefined ? entry.reference : null; + }, + checkTTL: function(time, ttl) + { + Debug.assert(ttl !== 0); + if(ttl < 0) // TTL = infinite + { + return true; + } + else + { + return Date.now() - time <= (ttl * 1000); + } + } + }); + + Ice.LocatorTable = LocatorTable; + global.Ice = Ice; + + var EndpointTableEntry = function(time, endpoints) + { + this.time = time; + this.endpoints = endpoints; + }; + + var ReferenceTableEntry = function(time, reference) + { + this.time = time; + this.reference = reference; + }; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Logger.js b/js/src/Ice/Logger.js new file mode 100644 index 00000000000..38ab8d8ee4b --- /dev/null +++ b/js/src/Ice/Logger.js @@ -0,0 +1,93 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + var Ice = global.Ice || {}; + + require("Ice/Class"); + + var Logger = Ice.Class({ + __init__: function(prefix) + { + if(prefix !== undefined && prefix.length > 0) + { + this._prefix = prefix + ": "; + } + else + { + this._prefix = ""; + } + }, + print: function(message) + { + this.write(message, false); + }, + trace: function(category, message) + { + var s = []; + var d = new Date(); + s.push("-- "); + s.push(this.timestamp()); + s.push(' '); + s.push(this._prefix); + s.push(category); + s.push(": "); + s.push(message); + this.write(s.join(""), true); + }, + warning: function(message) + { + var s = []; + var d = new Date(); + s.push("-! "); + s.push(this.timestamp()); + s.push(' '); + s.push(this._prefix); + s.push("warning: "); + s.push(message); + this.write(s.join(""), true); + }, + error: function(message) + { + var s = []; + var d = new Date(); + s.push("!! "); + s.push(this.timestamp()); + s.push(' '); + s.push(this._prefix); + s.push("error: "); + s.push(message); + this.write(s.join(""), true); + }, + cloneWithPrefix: function(prefix) + { + return new Logger(prefix); + }, + write: function(message, indent) + { + if(indent) + { + message = message.replace(/\n/g, "\n "); + } + + console.log(message); + }, + timestamp: function() + { + var d = new Date(); + var mon = d.getMonth() + 1; + mon = mon < 10 ? "0" + mon : mon; + var day = d.getDate(); + day = day < 10 ? "0" + day : day; + return mon + "-" + day + "-" + d.getFullYear() + " " + d.toLocaleTimeString() + "." + d.getMilliseconds(); + } + }); + Ice.Logger = Logger; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Long.js b/js/src/Ice/Long.js new file mode 100644 index 00000000000..1445b4098e9 --- /dev/null +++ b/js/src/Ice/Long.js @@ -0,0 +1,100 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + + // + // The Long type represents a signed 64-bit integer as two 32-bit values + // corresponding to the high and low words. + // + var Ice = global.Ice || {}; + + var Long = Ice.Class({ + __init__: function(high, low) + { + this.high = high; + this.low = low; + }, + hashCode: function() + { + return this.low; + }, + equals: function(rhs) + { + if(this === rhs) + { + return true; + } + if(!(rhs instanceof Long)) + { + return false; + } + return this.high === rhs.high && this.low === rhs.low; + }, + toString: function() + { + return this.high + ":" + this.low; + }, + toNumber: function() + { + if((this.high & Long.SIGN_MASK) != 0) + { + var low = ~this.low; + var high = ~this.high; + if(low < 0xFFFFFFFF) + { + low += 1; + } + else + { + low = 0; + high += 1; + if(high > Long.HIGH_MAX) + { + return Number.NEGATIVE_INFINITY; + } + } + return -1 * (high * Long.HIGH_MASK) + low; + } + else + { + if(this.high > Long.HIGH_MAX) + { + return Number.POSITIVE_INFINITY; + } + return (this.high * Long.HIGH_MASK) + this.low; + } + } + }); + + // + // (high & SIGN_MASK) != 0 denotes a negative number; + // that is, the most significant bit is set. + // + Long.SIGN_MASK = 0x80000000; + + // + // When converting to a JavaScript Number we left shift the + // high word by 32 bits. As that isn't possible using JavaScript's + // left shift operator, we multiply the value by 2^32 which will + // produce the same result. + // + Long.HIGH_MASK = 0x100000000; + + // + // The maximum value for the high word when coverting to + // a JavaScript Number is 2^21 - 1, in which case all + // 53 bits are used. + // + Long.HIGH_MAX = 0x1FFFFF; + + Ice.Long = Long; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Makefile b/js/src/Ice/Makefile new file mode 100644 index 00000000000..0b1edfc2694 --- /dev/null +++ b/js/src/Ice/Makefile @@ -0,0 +1,163 @@ +# ********************************************************************** +# +# Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +# +# This copy of Ice is licensed to you under the terms described in the +# ICE_LICENSE file included in this distribution. +# +# ********************************************************************** + +top_srcdir = ../.. + +LIBNAME = Ice + +TARGETS = $(call mklibtargets,$(LIBNAME)) + +SLICES = $(SDIR)/BuiltinSequences.ice \ + $(SDIR)/Connection.ice \ + $(SDIR)/ConnectionF.ice \ + $(SDIR)/Current.ice \ + $(SDIR)/Endpoint.ice \ + $(SDIR)/EndpointF.ice \ + $(SDIR)/EndpointTypes.ice \ + $(SDIR)/Identity.ice \ + $(SDIR)/LocalException.ice \ + $(SDIR)/Locator.ice \ + $(SDIR)/Metrics.ice \ + $(SDIR)/ObjectAdapterF.ice \ + $(SDIR)/Process.ice \ + $(SDIR)/ProcessF.ice \ + $(SDIR)/PropertiesAdmin.ice \ + $(SDIR)/Router.ice \ + $(SDIR)/SliceChecksumDict.ice \ + $(SDIR)/Version.ice + +SDIR = $(slicedir)/Ice + +GEN_SRCS = $(patsubst $(SDIR)/%.ice, %.js, $(SLICES)) + +COMMON_SRCS = \ + Address.js \ + ArrayUtil.js \ + AsyncResultBase.js \ + AsyncResult.js \ + AsyncStatus.js \ + Base64.js \ + BasicStream.js \ + BatchOutgoingAsync.js \ + Class.js \ + Communicator.js \ + ConnectionBatchOutgoingAsync.js \ + ConnectionI.js \ + ConnectionMonitor.js \ + ConnectionReaper.js \ + ConnectionRequestHandler.js \ + ConnectRequestHandler.js \ + DefaultsAndOverrides.js \ + DispatchStatus.js \ + EndpointFactoryManager.js \ + EnumBase.js \ + Exception.js \ + ExUtil.js \ + FormatType.js \ + HashMap.js \ + HashUtil.js \ + IdentityUtil.js \ + ImplicitContextI.js \ + IncomingAsync.js \ + Initialize.js \ + Instance.js \ + LocalExceptionWrapper.js \ + LocatorInfo.js \ + LocatorManager.js \ + LocatorTable.js \ + Logger.js \ + Long.js \ + ObjectAdapterFactory.js \ + ObjectAdapterI.js \ + ObjectFactory.js \ + ObjectFactoryManager.js \ + Object.js \ + ObjectPrx.js \ + OpaqueEndpointI.js \ + Operation.js \ + OptionalFormat.js \ + OutgoingAsync.js \ + OutgoingConnectionFactory.js \ + ProcessLogger.js \ + Promise.js \ + Properties.js \ + Property.js \ + PropertyNames.js \ + Protocol.js \ + ProxyBatchOutgoingAsync.js \ + ProxyFactory.js \ + Reference.js \ + ReferenceMode.js \ + RetryQueue.js \ + RouterInfo.js \ + RouterManager.js \ + ServantManager.js \ + SocketOperation.js \ + StreamHelpers.js \ + StringUtil.js \ + Struct.js \ + Timer.js \ + TraceLevels.js \ + TraceUtil.js \ + CompactIdRegistry.js \ + UnknownSlicedObject.js \ + UUID.js + +NODEJS_SRCS = \ + Buffer.js \ + Ice.js \ + TcpEndpointFactory.js \ + TcpEndpointI.js \ + TcpTransceiver.js \ + +BROWSER_SRCS = \ + browser/Buffer.js \ + browser/EndpointInfo.js \ + browser/ConnectionInfo.js \ + browser/Transceiver.js \ + browser/EndpointI.js \ + browser/EndpointFactory.js + +ifneq ($(OPTIMIZE),yes) + NODEJS_SRCS := $(NODEJS_SRCS) Debug.js + BROWSER_SRCS := $(BROWSER_SRCS) browser/Debug.js +endif + +SRCS := $(BROWSER_SRCS) $(GEN_SRCS) $(COMMON_SRCS) +INSTALL_SRCS := $(NODEJS_SRCS) $(GEN_SRCS) $(COMMON_SRCS) + +include $(top_srcdir)/config/Make.rules.js + +# Prevent generation of these files from .ice files +Communicator.js: + +Properties.js: + +Logger.js: + +ServantLocator.js: + +ObjectFactory.js: + + +SLICE2JSFLAGS := $(SLICE2JSFLAGS) --ice -I$(slicedir) + +# IceWS slice files +browser/%.js: $(slicedir)/IceWS/%.ice $(SLICE2JS) $(SLICEPARSERLIB) + rm -f browser/$(*F).js + $(SLICE2JS) $(SLICE2JSFLAGS) $< + mv $(*F).js browser/ + +lint:: $(SRCS) + jshint $(LINTFLAGS) $(NODEJS_SRCS) $(BROWSER_SRCS) $(GEN_SRCS) $(COMMON_SRCS) + +install:: all + $(call installlib,$(DESTDIR)$(install_libdir),$(libdir),$(LIBNAME)) + $(call installmodule,$(DESTDIR)$(install_moduledir),$(INSTALL_SRCS),$(LIBNAME)) + diff --git a/js/src/Ice/Makefile.mak b/js/src/Ice/Makefile.mak new file mode 100644 index 00000000000..17e2a3688a7 --- /dev/null +++ b/js/src/Ice/Makefile.mak @@ -0,0 +1,167 @@ +# ********************************************************************** +# +# Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +# +# This copy of Ice is licensed to you under the terms described in the +# ICE_LICENSE file included in this distribution. +# +# ********************************************************************** + +top_srcdir = ..\.. + +LIBNAME = Ice + +GEN_SRCS = BuiltinSequences.js \ + Connection.js \ + ConnectionF.js \ + Current.js \ + Endpoint.js \ + EndpointF.js \ + EndpointTypes.js \ + Identity.js \ + LocalException.js \ + Locator.js \ + Metrics.js \ + ObjectAdapterF.js \ + Process.js \ + ProcessF.js \ + PropertiesAdmin.js \ + Router.js \ + SliceChecksumDict.js \ + Version.js + +COMMON_SRCS = \ + Address.js \ + ArrayUtil.js \ + AsyncResultBase.js \ + AsyncResult.js \ + AsyncStatus.js \ + Base64.js \ + BasicStream.js \ + BatchOutgoingAsync.js \ + Class.js \ + Communicator.js \ + ConnectionBatchOutgoingAsync.js \ + ConnectionI.js \ + ConnectionMonitor.js \ + ConnectionReaper.js \ + ConnectionRequestHandler.js \ + ConnectRequestHandler.js \ + DefaultsAndOverrides.js \ + DispatchStatus.js \ + EndpointFactoryManager.js \ + EnumBase.js \ + Exception.js \ + ExUtil.js \ + FormatType.js \ + HashMap.js \ + HashUtil.js \ + IdentityUtil.js \ + ImplicitContextI.js \ + IncomingAsync.js \ + Initialize.js \ + Instance.js \ + LocalExceptionWrapper.js \ + LocatorInfo.js \ + LocatorManager.js \ + LocatorTable.js \ + Logger.js \ + Long.js \ + ObjectAdapterFactory.js \ + ObjectAdapterI.js \ + ObjectFactory.js \ + ObjectFactoryManager.js \ + Object.js \ + ObjectPrx.js \ + OpaqueEndpointI.js \ + Operation.js \ + OptionalFormat.js \ + OutgoingAsync.js \ + OutgoingConnectionFactory.js \ + ProcessLogger.js \ + Promise.js \ + Properties.js \ + Property.js \ + PropertyNames.js \ + Protocol.js \ + ProxyBatchOutgoingAsync.js \ + ProxyFactory.js \ + Reference.js \ + ReferenceMode.js \ + RetryQueue.js \ + RouterInfo.js \ + RouterManager.js \ + ServantManager.js \ + SocketOperation.js \ + StreamHelpers.js \ + StringUtil.js \ + Struct.js \ + Timer.js \ + TraceLevels.js \ + TraceUtil.js \ + CompactIdRegistry.js \ + UnknownSlicedObject.js \ + UUID.js + +NODEJS_SRCS = \ + Buffer.js \ + Ice.js \ + TcpEndpointFactory.js \ + TcpEndpointI.js \ + TcpTransceiver.js \ + +BROWSER_SRCS = \ + browser\Buffer.js \ + browser\EndpointInfo.js \ + browser\ConnectionInfo.js \ + browser\Transceiver.js \ + browser\EndpointI.js \ + browser\EndpointFactory.js + +!if "$(OPTIMIZE)" != "yes" +NODEJS_SRCS = $(NODEJS_SRCS) Debug.js +BROWSER_SRCS = $(BROWSER_SRCS) browser\Debug.js +!endif + +SDIR = $(slicedir)\Ice + +SRCS = $(BROWSER_SRCS) $(GEN_SRCS) $(COMMON_SRCS) +INSTALL_SRCS = $(NODEJS_SRCS) $(GEN_SRCS) $(COMMON_SRCS) + +!include $(top_srcdir)\config\Make.rules.mak.js + +# Prevent generation of these files from .ice files +Communicator.js: + +Properties.js: + +Logger.js: + +ServantLocator.js: + +ObjectFactory.js: + + +SLICE2JSFLAGS = $(SLICE2JSFLAGS) --ice -I"$(slicedir)" + +# IceWS slice files +browser\EndpointInfo.js: "$(SLICE2JS)" "$(SLICEPARSERLIB)" + del /q browser\EndpointInfo.js + "$(SLICE2JS)" $(SLICE2JSFLAGS) "$(slicedir)\IceWS\EndpointInfo.ice" + move EndpointInfo.js browser + +browser\ConnectionInfo.js: "$(SLICE2JS)" "$(SLICEPARSERLIB)" + -del /q browser\ConnectionInfo.js + "$(SLICE2JS)" $(SLICE2JSFLAGS) "$(slicedir)\IceWS\ConnectionInfo.ice" + move ConnectionInfo.js browser + +MODULEDIR = $(install_moduledir)\$(LIBNAME) + +install:: all + @if not exist $(MODULEDIR) \ + @echo "Creating $(MODULEDIR)" && \ + mkdir "$(MODULEDIR)" + @for %i in ( $(INSTALL_SRCS) ) do \ + copy %i "$(MODULEDIR)" + copy package.json "$(MODULEDIR)" + diff --git a/js/src/Ice/Object.js b/js/src/Ice/Object.js new file mode 100644 index 00000000000..a60a60d6d9d --- /dev/null +++ b/js/src/Ice/Object.js @@ -0,0 +1,307 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + // + // Ice.Object + // + // Using IceObject in this file to avoid collisions with the native Object. + // + require("Ice/Class"); + require("Ice/DispatchStatus"); + require("Ice/Exception"); + require("Ice/FormatType"); + require("Ice/StreamHelpers"); + require("Ice/OptionalFormat"); + + var Ice = global.Ice || {}; + var Slice = global.Slice || {}; + + var Class = Ice.Class; + + var nextAddress = 0; + + var IceObject = Class({ + __init__: function() + { + // Fake Address used as the hashCode for this object instance. + this.__address = nextAddress++; + }, + hashCode: function() + { + return this.__address; + }, + ice_isA: function(s, current) + { + return this.__mostDerivedType().__ids.indexOf(s) >= 0; + }, + ice_ping: function(current) + { + }, + ice_ids: function(current) + { + return this.__mostDerivedType().__ids; + }, + ice_id: function(current) + { + return this.__mostDerivedType().__id; + }, + toString: function() + { + return "[object " + this.ice_id() + "]"; + }, + ice_preMarshal: function() + { + }, + ice_postUnmarshal: function() + { + }, + __write: function(os) + { + os.startWriteObject(null); + __writeImpl(this, os, this.__mostDerivedType()); + os.endWriteObject(); + }, + __read: function(is) + { + is.startReadObject(); + __readImpl(this, is, this.__mostDerivedType()); + is.endReadObject(false); + }, + ice_instanceof: function(T) + { + if(T) + { + if(this instanceof T) + { + return true; + } + return this.__mostDerivedType().__instanceof(T); + } + return false; + }, + // + // __mostDerivedType returns the the most derived Ice generated class. This is + // necessary because the user might extend Slice generated classes. The user + // class extensions don't have __id, __ids, __instanceof etc static members so + // the implementation of ice_id, ice_ids and ice_instanceof would fail trying + // to access those members of the user defined class. Instead, ice_id, ice_ids + // and ice_instanceof call __mostDerivedType to get the most derived Ice class. + // + // The __mostDerivedType is overriden by each Slice generated class, see the + // Slice.defineObject method implementation for details. + // + __mostDerivedType: function() + { + return IceObject; + } + }); + + // + // These methods are used for object parameters. + // + IceObject.write = function(os, v) + { + os.writeObject(v); + }; + + IceObject.writeOpt = function(os, tag, v) + { + os.writeOptObject(tag, v); + }; + + IceObject.read = function(is) + { + var v = { value: null }; + is.readObject(function(o) { v.value = o; }, IceObject); + return v; + }; + + IceObject.readOpt = function(is, tag) + { + var v = { value: undefined }; + is.readOptObject(tag, function(o) { v.value = o; }, IceObject); + return v; + }; + + IceObject.ice_staticId = function() + { + return IceObject.__id; + }; + + IceObject.__instanceof = function(T) + { + if(T === this) + { + return true; + } + + for(var i in this.__implements) + { + if(this.__implements[i].__instanceof(T)) + { + return true; + } + } + + if(this.__parent) + { + return this.__parent.__instanceof(T); + } + return false; + }; + + IceObject.__ids = ["::Ice::Object"]; + IceObject.__id = IceObject.__ids[0]; + IceObject.__compactId = -1; + IceObject.__preserved = false; + + // + // Private methods + // + + var __writeImpl = function(obj, os, type) + { + // + // The __writeImpl method is a recursive method that goes down the + // class hierarchy to marshal each slice of the class using the + // generated __writeMemberImpl method. + // + + if(type === undefined || type === IceObject) + { + return; // Don't marshal anything for IceObject + } + + os.startWriteSlice(type.__id, type.__compactId, type.__parent === IceObject); + if(type.prototype.__writeMemberImpl) + { + type.prototype.__writeMemberImpl.call(obj, os); + } + os.endWriteSlice(); + __writeImpl(obj, os, type.__parent); + }; + + var __readImpl = function(obj, is, type) + { + // + // The __readImpl method is a recursive method that goes down the + // class hierarchy to marshal each slice of the class using the + // generated __readMemberImpl method. + // + + if(type === undefined || type === IceObject) + { + return; // Don't marshal anything for IceObject + } + + is.startReadSlice(); + if(type.prototype.__readMemberImpl) + { + type.prototype.__readMemberImpl.call(obj, is); + } + is.endReadSlice(); + __readImpl(obj, is, type.__parent); + }; + + var __writePreserved = function(os) + { + // + // For Slice classes which are marked "preserved", the implementation of this method + // replaces the Ice.Object.prototype.__write method. + // + os.startWriteObject(this.__slicedData); + __writeImpl(this, os, this.__mostDerivedType()); + os.endWriteObject(); + }; + + var __readPreserved = function(is) + { + // + // For Slice classes which are marked "preserved", the implementation of this method + // replaces the Ice.Object.prototype.__read method. + // + is.startReadObject(); + __readImpl(this, is, this.__mostDerivedType()); + this.__slicedData = is.endReadObject(true); + }; + + Ice.Object = IceObject; + + Slice.defineLocalObject = function(constructor, base) + { + var obj = constructor || function(){}; + + if(base !== undefined) + { + obj.prototype = new base(); + obj.__parent = base; + obj.prototype.constructor = constructor; + } + + return obj; + }; + + Slice.defineObject = function(constructor, base, intfs, scope, ids, compactId, writeImpl, readImpl, preserved) + { + var obj = constructor || function(){}; + + obj.prototype = new base(); + obj.__parent = base; + obj.__ids = ids; + obj.__id = ids[scope]; + obj.__compactId = compactId; + obj.__instanceof = IceObject.__instanceof; + obj.__implements = intfs; + + // + // These methods are used for object parameters. + // + obj.write = function(os, v) + { + os.writeObject(v); + }; + obj.writeOpt = function(os, tag, v) + { + os.writeOptObject(tag, v); + }; + obj.read = function(is) + { + var v = { value: null }; + is.readObject(function(o) { v.value = o; }, obj); + return v; + }; + obj.readOpt = function(is, tag) + { + var v = { value: undefined }; + is.readOptObject(tag, function(o) { v.value = o; }, obj); + return v; + }; + + obj.ice_staticId = function() + { + return ids[scope]; + }; + + obj.prototype.constructor = obj; + obj.prototype.__mostDerivedType = function() { return obj; }; + if(preserved) + { + obj.prototype.__write = __writePreserved; + obj.prototype.__read = __readPreserved; + } + obj.prototype.__writeMemberImpl = writeImpl; + obj.prototype.__readMemberImpl = readImpl; + + return obj; + }; + + global.Slice = Slice; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ObjectAdapterFactory.js b/js/src/Ice/ObjectAdapterFactory.js new file mode 100644 index 00000000000..8fe50d5d872 --- /dev/null +++ b/js/src/Ice/ObjectAdapterFactory.js @@ -0,0 +1,150 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/AsyncResultBase"); + require("Ice/LocalException"); + require("Ice/ObjectAdapterI"); + require("Ice/Promise"); + require("Ice/UUID"); + + var Ice = global.Ice || {}; + + var AsyncResultBase = Ice.AsyncResultBase; + var ObjectAdapterI = Ice.ObjectAdapterI; + var Promise = Ice.Promise; + var UUID = Ice.UUID; + + // + // Only for use by Instance. + // + var ObjectAdapterFactory = Ice.Class({ + __init__: function(instance, communicator) + { + this._instance = instance; + this._communicator = communicator; + this._adapters = []; + this._adapterNamesInUse = []; + this._shutdownPromise = new Promise(); + }, + shutdown: function() + { + // + // Ignore shutdown requests if the object adapter factory has + // already been shut down. + // + if(this._instance === null) + { + return this._shutdownPromise; + } + + this._instance = null; + this._communicator = null; + var self = this; + Promise.all( + this._adapters.map(function(adapter) + { + return adapter.deactivate(); + }) + ).then( + function() + { + self._shutdownPromise.succeed(); + }, + function(ex) + { + self._shutdownPromise.fail(ex); + } + ); + return this._shutdownPromise; + }, + waitForShutdown: function() + { + var self = this; + return this._shutdownPromise.then( + function() + { + return Promise.all(self._adapters.map(function(adapter) + { + return adapter.waitForDeactivate(); + })); + }); + }, + isShutdown: function() + { + return this._instance === null; + }, + destroy: function() + { + var self = this; + return this.waitForShutdown().then( + function() + { + return Promise.all(self._adapters.map(function(adapter) + { + return adapter.destroy(); + })); + }); + }, + createObjectAdapter: function(name, router, promise) + { + if(this._instance === null) + { + throw new Ice.ObjectAdapterDeactivatedException(); + } + + var adapter = null; + try + { + if(name.length === 0) + { + var uuid = UUID.generateUUID(); + adapter = new ObjectAdapterI(this._instance, this._communicator, this, uuid, null, true, promise); + } + else + { + if(this._adapterNamesInUse.indexOf(name) !== -1) + { + throw new Ice.AlreadyRegisteredException("object adapter", name); + } + adapter = new ObjectAdapterI(this._instance, this._communicator, this, name, router, false, promise); + this._adapterNamesInUse.push(name); + } + this._adapters.push(adapter); + } + catch(ex) + { + promise.fail(ex, promise); + } + }, + removeObjectAdapter: function(adapter) + { + if(this._instance === null) + { + return; + } + + var n = this._adapters.indexOf(adapter); + if(n !== -1) + { + this._adapters.splice(n, 1); + } + + n = this._adapterNamesInUse.indexOf(adapter.getName()); + if(n !== -1) + { + this._adapterNamesInUse.splice(n, 1); + } + } + }); + + Ice.ObjectAdapterFactory = ObjectAdapterFactory; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ObjectAdapterI.js b/js/src/Ice/ObjectAdapterI.js new file mode 100644 index 00000000000..422b6a759e6 --- /dev/null +++ b/js/src/Ice/ObjectAdapterI.js @@ -0,0 +1,547 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/AsyncResultBase"); + require("Ice/Debug"); + require("Ice/Identity"); + require("Ice/LocalException"); + require("Ice/Promise"); + require("Ice/PropertyNames"); + require("Ice/Router"); + require("Ice/ServantManager"); + require("Ice/StringUtil"); + require("Ice/UUID"); + + var Ice = global.Ice || {}; + + var AsyncResultBase = Ice.AsyncResultBase; + var Debug = Ice.Debug; + var Identity = Ice.Identity; + var Promise = Ice.Promise; + var PropertyNames = Ice.PropertyNames; + var ServantManager = Ice.ServantManager; + var StringUtil = Ice.StringUtil; + var UUID = Ice.UUID; + + var _suffixes = + [ + "ACM", + "AdapterId", + "Endpoints", + "Locator", + "Locator.EncodingVersion", + "Locator.EndpointSelection", + "Locator.ConnectionCached", + "Locator.PreferSecure", + "Locator.CollocationOptimized", + "Locator.Router", + "PublishedEndpoints", + "RegisterProcess", + "ReplicaGroupId", + "Router", + "Router.EncodingVersion", + "Router.EndpointSelection", + "Router.ConnectionCached", + "Router.PreferSecure", + "Router.CollocationOptimized", + "Router.Locator", + "Router.Locator.EndpointSelection", + "Router.Locator.ConnectionCached", + "Router.Locator.PreferSecure", + "Router.Locator.CollocationOptimized", + "Router.Locator.LocatorCacheTimeout", + "Router.LocatorCacheTimeout", + "ProxyOptions", + "ThreadPool.Size", + "ThreadPool.SizeMax", + "ThreadPool.SizeWarn", + "ThreadPool.StackSize", + "ThreadPool.Serialize" + ]; + + // + // Only for use by IceInternal.ObjectAdapterFactory + // + var ObjectAdapterI = Ice.Class({ + __init__: function(instance, communicator, objectAdapterFactory, name, router, noConfig, promise) + { + this._deactivated = false; + this._instance = instance; + this._communicator = communicator; + this._objectAdapterFactory = objectAdapterFactory; + this._servantManager = new ServantManager(instance, name); + this._name = name; + this._routerEndpoints = []; + this._routerInfo = null; + this._destroyed = false; + this._noConfig = noConfig; + + if(this._noConfig) + { + this._reference = this._instance.referenceFactory().createFromString("dummy -t", ""); + promise.succeed(this, promise); + return; + } + + var properties = this._instance.initializationData().properties; + var unknownProps = []; + var noProps = this.filterProperties(unknownProps); + + // + // Warn about unknown object adapter properties. + // + if(unknownProps.length !== 0 && properties.getPropertyAsIntWithDefault("Ice.Warn.UnknownProperties", 1) > 0) + { + var message = ["found unknown properties for object adapter `" + name + "':"]; + for(var i = 0; i < unknownProps.length; ++i) + { + message.push("\n " + unknownProps[i]); + } + this._instance.initializationData().logger.warning(message.join("")); + } + + // + // Make sure named adapter has some configuration. + // + if(router === null && noProps) + { + var ex = new Ice.InitializationException(); + ex.reason = "object adapter `" + this._name + "' requires configuration"; + throw ex; + } + + // + // Setup a reference to be used to get the default proxy options + // when creating new proxies. By default, create twoway proxies. + // + var proxyOptions = properties.getPropertyWithDefault(this._name + ".ProxyOptions", "-t"); + try + { + this._reference = this._instance.referenceFactory().createFromString("dummy " + proxyOptions, ""); + } + catch(e) + { + if(e instanceof Ice.ProxyParseException) + { + var ex = new Ice.InitializationException(); + ex.reason = "invalid proxy options `" + proxyOptions + "' for object adapter `" + name + "'"; + throw ex; + } + else + { + throw e; + } + } + + try + { + + if(router === null) + { + router = Ice.RouterPrx.uncheckedCast( + this._instance.proxyFactory().propertyToProxy(this._name + ".Router")); + } + if(router !== null) + { + this._routerInfo = this._instance.routerManager().find(router); + Debug.assert(this._routerInfo !== null); + + // + // Make sure this router is not already registered with another adapter. + // + if(this._routerInfo.getAdapter() !== null) + { + throw new Ice.AlreadyRegisteredException( + "object adapter with router", + this._instance.identityToString(router.ice_getIdentity())); + } + + // + // Add the router's server proxy endpoints to this object + // adapter. + // + var self = this; + this._routerInfo.getServerEndpoints().then( + function(endpoints) + { + var i; + + for(i = 0; i < endpoints.length; ++i) + { + self._routerEndpoints.push(endpoints[i]); + } + self._routerEndpoints.sort( // Must be sorted. + function(e1, e2) + { + return e1.compareTo(e2); + }); + + // + // Remove duplicate endpoints, so we have a list of unique + // endpoints. + // + for(i = 0; i < self._routerEndpoints.length - 1;) + { + var e1 = self._routerEndpoints[i]; + var e2 = self._routerEndpoints[i + 1]; + if(e1.equals(e2)) + { + self._routerEndpoints.splice(i, 1); + } + else + { + ++i; + } + } + + // + // Associate this object adapter with the router. This way, + // new outgoing connections to the router's client proxy will + // use this object adapter for callbacks. + // + self._routerInfo.setAdapter(self); + + // + // Also modify all existing outgoing connections to the + // router's client proxy to use this object adapter for + // callbacks. + // + return self._instance.outgoingConnectionFactory().setRouterInfo(self._routerInfo); + } + ).then( + function() + { + promise.succeed(self, promise); + }, + function(ex) + { + promise.fail(ex, promise); + }); + } + else + { + var endpoints = properties.getProperty(this._name + ".Endpoints"); + if(endpoints.length > 0) + { + throw new Ice.FeatureNotSupportedException("object adapter endpoints not supported"); + } + promise.succeed(this, promise); + } + } + catch(ex) + { + this.destroy(); + throw ex; + } + }, + getName: function() + { + // + // No mutex lock necessary, _name is immutable. + // + return this._noConfig ? "" : this._name; + }, + getCommunicator: function() + { + return this._communicator; + }, + activate: function() + { + }, + hold: function() + { + this.checkForDeactivation(); + }, + waitForHold: function() + { + var promise = new AsyncResultBase(this._communicator, "waitForHold", null, null, this); + if(adapter.checkForDeactivation(promise)) + { + return promise; + } + return promise.succeed(promise); + }, + deactivate: function() + { + var promise = new AsyncResultBase(this._communicator, "deactivate", null, null, this); + if(!this._deactivated) + { + this._deactivated = true; + this._instance.outgoingConnectionFactory().removeAdapter(this); + } + return promise.succeed(promise); + }, + waitForDeactivate: function() + { + var promise = new AsyncResultBase(this._communicator, "deactivate", null, null, this); + return promise.succeed(promise); + }, + isDeactivated: function() + { + return this._deactivated; + }, + destroy: function() + { + var promise = new AsyncResultBase(this._communicator, "destroy", null, null, this); + if(!this._deactivated) + { + this.deactivate(); + } + if(!this._destroyed) + { + this._destroyed = true; + this._servantManager.destroy(); + this._objectAdapterFactory.removeObjectAdapter(this); + } + return promise.succeed(promise); + }, + add: function(object, ident) + { + return this.addFacet(object, ident, ""); + }, + addFacet: function(object, ident, facet) + { + this.checkForDeactivation(); + this.checkIdentity(ident); + + // + // Create a copy of the Identity argument, in case the caller + // reuses it. + // + var id = ident.clone(); + + this._servantManager.addServant(object, id, facet); + + return this.newProxy(id, facet); + }, + addWithUUID: function(object) + { + return this.addFacetWithUUID(object, ""); + }, + addFacetWithUUID: function(object, facet) + { + return this.addFacet(object, new Identity(UUID.generateUUID(), ""), facet); + }, + addDefaultServant: function(servant, category) + { + this.checkForDeactivation(); + + this._servantManager.addDefaultServant(servant, category); + }, + remove: function(ident) + { + return this.removeFacet(ident, ""); + }, + removeFacet: function(ident, facet) + { + this.checkForDeactivation(); + this.checkIdentity(ident); + + return this._servantManager.removeServant(ident, facet); + }, + removeAllFacets: function(ident) + { + this.checkForDeactivation(); + this.checkIdentity(ident); + + return this._servantManager.removeAllFacets(ident); + }, + removeDefaultServant: function(category) + { + this.checkForDeactivation(); + + return this._servantManager.removeDefaultServant(category); + }, + find: function(ident) + { + return this.findFacet(ident, ""); + }, + findFacet: function(ident, facet) + { + this.checkForDeactivation(); + this.checkIdentity(ident); + + return this._servantManager.findServant(ident, facet); + }, + findAllFacets: function(ident) + { + this.checkForDeactivation(); + this.checkIdentity(ident); + + return this._servantManager.findAllFacets(ident); + }, + findByProxy: function(proxy) + { + this.checkForDeactivation(); + + var ref = proxy.__reference(); + return this.findFacet(ref.getIdentity(), ref.getFacet()); + }, + findDefaultServant: function(category) + { + this.checkForDeactivation(); + + return this._servantManager.findDefaultServant(category); + }, + addServantLocator: function(locator, prefix) + { + this.checkForDeactivation(); + + this._servantManager.addServantLocator(locator, prefix); + }, + removeServantLocator: function(prefix) + { + this.checkForDeactivation(); + + return this._servantManager.removeServantLocator(prefix); + }, + findServantLocator: function(prefix) + { + this.checkForDeactivation(); + + return this._servantManager.findServantLocator(prefix); + }, + createProxy: function(ident) + { + this.checkForDeactivation(); + this.checkIdentity(ident); + + return this.newProxy(ident, ""); + }, + createDirectProxy: function(ident) + { + return this.createProxy(ident); + }, + createIndirectProxy: function(ident) + { + throw new Ice.FeatureNotSupportedException("setLocator not supported"); + }, + setLocator: function(locator) + { + throw new Ice.FeatureNotSupportedException("setLocator not supported"); + }, + refreshPublishedEndpoints: function() + { + throw new Ice.FeatureNotSupportedException("refreshPublishedEndpoints not supported"); + }, + getEndpoints: function() + { + return []; + }, + getPublishedEndpoints: function() + { + return []; + }, + getServantManager: function() + { + // + // _servantManager is immutable. + // + return this._servantManager; + }, + newProxy: function(ident, facet) + { + var endpoints = []; + + // + // Now we also add the endpoints of the router's server proxy, if + // any. This way, object references created by this object adapter + // will also point to the router's server proxy endpoints. + // + for(var i = 0; i < this._routerEndpoints.length; ++i) + { + endpoints.push(this._routerEndpoints[i]); + } + + // + // Create a reference and return a proxy for this reference. + // + var ref = this._instance.referenceFactory().create(ident, facet, this._reference, endpoints); + return this._instance.proxyFactory().referenceToProxy(ref); + }, + checkForDeactivation: function(promise) + { + if(this._deactivated) + { + var ex = new Ice.ObjectAdapterDeactivatedException(); + ex.name = this.getName(); + + if(promise !== undefined) + { + promise.fail(ex, promise); + return true; + } + else + { + throw ex; + } + } + + return false; + }, + checkIdentity: function(ident) + { + if(ident.name === undefined || ident.name === null || ident.name.length === 0) + { + var e = new Ice.IllegalIdentityException(); + e.id = ident.clone(); + throw e; + } + + if(ident.category === undefined || ident.category === null) + { + ident.category = ""; + } + }, + filterProperties: function(unknownProps) + { + // + // Do not create unknown properties list if Ice prefix, i.e., Ice, Glacier2, etc. + // + var addUnknown = true, i; + var prefix = this._name + "."; + for(i = 0; i < PropertyNames.clPropNames.length; ++i) + { + if(prefix.indexOf(PropertyNames.clPropNames[i] + ".") === 0) + { + addUnknown = false; + break; + } + } + + var noProps = true; + var props = this._instance.initializationData().properties.getPropertiesForPrefix(prefix); + for(var e = props.entries; e !== null; e = e.next) + { + var valid = false; + for(i = 0; i < _suffixes.length; ++i) + { + if(e.key === prefix + _suffixes[i]) + { + noProps = false; + valid = true; + break; + } + } + + if(!valid && addUnknown) + { + unknownProps.push(e.key); + } + } + + return noProps; + } + }); + + Ice.ObjectAdapterI = ObjectAdapterI; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ObjectFactory.js b/js/src/Ice/ObjectFactory.js new file mode 100644 index 00000000000..2f178c4c73c --- /dev/null +++ b/js/src/Ice/ObjectFactory.js @@ -0,0 +1,28 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + var Ice = global.Ice || {}; + + require("Ice/Class"); + + var ObjectFactory = Ice.Class({ + create: function(type) + { + throw new Error("not implemented"); + }, + destroy: function() + { + throw new Error("not implemented"); + } + }); + + Ice.ObjectFactory = ObjectFactory; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ObjectFactoryManager.js b/js/src/Ice/ObjectFactoryManager.js new file mode 100644 index 00000000000..bffaeaa3070 --- /dev/null +++ b/js/src/Ice/ObjectFactoryManager.js @@ -0,0 +1,76 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/HashMap"); + require("Ice/LocalException"); + + var Ice = global.Ice || {}; + + var HashMap = Ice.HashMap; + var AlreadyRegisteredException = Ice.AlreadyRegisteredException; + var NotRegisteredException = Ice.NotRegisteredException; + + // + // Only for use by Instance + // + var ObjectFactoryManager = Ice.Class({ + __init__: function() + { + this._factoryMap = new HashMap(); // Map<String, ObjectFactory> + }, + add: function(factory, id) + { + var o, ex; + o = this._factoryMap.get(id); + if(o !== undefined) + { + ex = new AlreadyRegisteredException(); + ex.id = id; + ex.kindOfObject = "object factory"; + throw ex; + } + this._factoryMap.set(id, factory); + }, + remove: function(id) + { + var factory, ex; + factory = this._factoryMap.get(id); + if(factory === undefined) + { + ex = new NotRegisteredException(); + ex.id = id; + ex.kindOfObject = "object factory"; + throw ex; + } + this._factoryMap.delete(id); + factory.destroy(); + }, + find: function(id) + { + return this._factoryMap.get(id); + }, + destroy: function() + { + var oldMap = this._factoryMap, + e = oldMap.entries; + this._factoryMap = new HashMap(); // Map<String, ObjectFactory> + + while(e !== null) + { + e.value.destroy(); + e = e.next; + } + } + }); + + Ice.ObjectFactoryManager = ObjectFactoryManager; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ObjectPrx.js b/js/src/Ice/ObjectPrx.js new file mode 100644 index 00000000000..e6e2e0da9aa --- /dev/null +++ b/js/src/Ice/ObjectPrx.js @@ -0,0 +1,967 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/ArrayUtil"); + require("Ice/AsyncResult"); + require("Ice/ConnectRequestHandler"); + require("Ice/Debug"); + require("Ice/FormatType"); + require("Ice/HashMap"); + require("Ice/OutgoingAsync"); + require("Ice/ProxyBatchOutgoingAsync"); + require("Ice/ReferenceMode"); + require("Ice/Current"); + require("Ice/Exception"); + require("Ice/BuiltinSequences"); + require("Ice/LocalException"); + require("Ice/Object"); + + var Ice = global.Ice || {}; + var Slice = global.Slice || {}; + + var ArrayUtil = Ice.ArrayUtil; + var AsyncResultBase = Ice.AsyncResultBase; + var AsyncResult = Ice.AsyncResult; + var ConnectRequestHandler = Ice.ConnectRequestHandler; + var Debug = Ice.Debug; + var FormatType = Ice.FormatType; + var HashMap = Ice.HashMap; + var OutgoingAsync = Ice.OutgoingAsync; + var ProxyBatchOutgoingAsync = Ice.ProxyBatchOutgoingAsync; + var RefMode = Ice.ReferenceMode; + var OperationMode = Ice.OperationMode; + + // + // Ice.ObjectPrx + // + var ObjectPrx = Ice.Class({ + __init__: function() + { + this._reference = null; + this._handler = null; + }, + hashCode: function(r) + { + return this._reference.hashCode(); + }, + ice_getCommunicator: function() + { + return this._reference.getCommunicator(); + }, + toString: function() + { + return this._reference.toString(); + }, + ice_getIdentity: function() + { + return this._reference.getIdentity().clone(); + }, + ice_identity: function(newIdentity) + { + if(newIdentity === undefined || newIdentity === null || newIdentity.name.length === 0) + { + throw new Ice.IllegalIdentityException(); + } + if(newIdentity.equals(this._reference.getIdentity())) + { + return this; + } + else + { + var proxy = new ObjectPrx(); + proxy.__setup(this._reference.changeIdentity(newIdentity)); + return proxy; + } + }, + ice_getContext: function() + { + return new HashMap(this._reference.getContext()); + }, + ice_context: function(newContext) + { + return this.__newInstance(this._reference.changeContext(newContext)); + }, + ice_getFacet: function() + { + return this._reference.getFacet(); + }, + ice_facet: function(newFacet) + { + if(newFacet === undefined || newFacet === null) + { + newFacet = ""; + } + + if(newFacet === this._reference.getFacet()) + { + return this; + } + else + { + var proxy = new ObjectPrx(); + proxy.__setup(this._reference.changeFacet(newFacet)); + return proxy; + } + }, + ice_getAdapterId: function() + { + return this._reference.getAdapterId(); + }, + ice_adapterId: function(newAdapterId) + { + if(newAdapterId === undefined || newAdapterId === null) + { + newAdapterId = ""; + } + + if(newAdapterId === this._reference.getAdapterId()) + { + return this; + } + else + { + return this.__newInstance(this._reference.changeAdapterId(newAdapterId)); + } + }, + ice_getEndpoints: function() + { + return ArrayUtil.clone(this._reference.getEndpoints()); + }, + ice_endpoints: function(newEndpoints) + { + if(newEndpoints === undefined || newEndpoints === null) + { + newEndpoints = []; + } + + if(ArrayUtil.equals(newEndpoints, this._reference.getEndpoints())) + { + return this; + } + else + { + return this.__newInstance(this._reference.changeEndpoints(newEndpoints)); + } + }, + ice_getLocatorCacheTimeout: function() + { + return this._reference.getLocatorCacheTimeout(); + }, + ice_locatorCacheTimeout: function(newTimeout) + { + if(newTimeout === this._reference.getLocatorCacheTimeout()) + { + return this; + } + else + { + return this.__newInstance(this._reference.changeLocatorCacheTimeout(newTimeout)); + } + }, + ice_isConnectionCached: function() + { + return this._reference.getCacheConnection(); + }, + ice_connectionCached: function(newCache) + { + if(newCache === this._reference.getCacheConnection()) + { + return this; + } + else + { + return this.__newInstance(this._reference.changeCacheConnection(newCache)); + } + }, + ice_getEndpointSelection: function() + { + return this._reference.getEndpointSelection(); + }, + ice_endpointSelection: function(newType) + { + if(newType === this._reference.getEndpointSelection()) + { + return this; + } + else + { + return this.__newInstance(this._reference.changeEndpointSelection(newType)); + } + }, + ice_isSecure: function() + { + return this._reference.getSecure(); + }, + ice_secure: function(b) + { + if(b === this._reference.getSecure()) + { + return this; + } + else + { + return this.__newInstance(this._reference.changeSecure(b)); + } + }, + ice_getEncodingVersion: function() + { + return this._reference.getEncoding().clone(); + }, + ice_encodingVersion: function(e) + { + if(e.equals(this._reference.getEncoding())) + { + return this; + } + else + { + return this.__newInstance(this._reference.changeEncoding(e)); + } + }, + ice_isPreferSecure: function() + { + return this._reference.getPreferSecure(); + }, + ice_preferSecure: function(b) + { + if(b === this._reference.getPreferSecure()) + { + return this; + } + else + { + return this.__newInstance(this._reference.changePreferSecure(b)); + } + }, + ice_getRouter: function() + { + var ri = this._reference.getRouterInfo(); + return ri !== null ? ri.getRouter() : null; + }, + ice_router: function(router) + { + var ref = this._reference.changeRouter(router); + if(ref.equals(this._reference)) + { + return this; + } + else + { + return this.__newInstance(ref); + } + }, + ice_getLocator: function() + { + var ri = this._reference.getLocatorInfo(); + return ri !== null ? ri.getLocator() : null; + }, + ice_locator: function(locator) + { + var ref = this._reference.changeLocator(locator); + if(ref.equals(this._reference)) + { + return this; + } + else + { + return this.__newInstance(ref); + } + }, + ice_isTwoway: function() + { + return this._reference.getMode() === RefMode.ModeTwoway; + }, + ice_twoway: function() + { + if(this._reference.getMode() === RefMode.ModeTwoway) + { + return this; + } + else + { + return this.__newInstance(this._reference.changeMode(RefMode.ModeTwoway)); + } + }, + ice_isOneway: function() + { + return this._reference.getMode() === RefMode.ModeOneway; + }, + ice_oneway: function() + { + if(this._reference.getMode() === RefMode.ModeOneway) + { + return this; + } + else + { + return this.__newInstance(this._reference.changeMode(RefMode.ModeOneway)); + } + }, + ice_isBatchOneway: function() + { + return this._reference.getMode() === RefMode.ModeBatchOneway; + }, + ice_batchOneway: function() + { + if(this._reference.getMode() === RefMode.ModeBatchOneway) + { + return this; + } + else + { + return this.__newInstance(this._reference.changeMode(RefMode.ModeBatchOneway)); + } + }, + ice_isDatagram: function() + { + return this._reference.getMode() === RefMode.ModeDatagram; + }, + ice_datagram: function() + { + if(this._reference.getMode() === RefMode.ModeDatagram) + { + return this; + } + else + { + return this.__newInstance(this._reference.changeMode(RefMode.ModeDatagram)); + } + }, + ice_isBatchDatagram: function() + { + return this._reference.getMode() === RefMode.ModeBatchDatagram; + }, + ice_batchDatagram: function() + { + if(this._reference.getMode() === RefMode.ModeBatchDatagram) + { + return this; + } + else + { + return this.__newInstance(this._reference.changeMode(RefMode.ModeBatchDatagram)); + } + }, + ice_compress: function(co) + { + var ref = this._reference.changeCompress(co); + if(ref.equals(this._reference)) + { + return this; + } + else + { + return this.__newInstance(ref); + } + }, + ice_timeout: function(t) + { + var ref = this._reference.changeTimeout(t); + if(ref.equals(this._reference)) + { + return this; + } + else + { + return this.__newInstance(ref); + } + }, + ice_getConnectionId: function() + { + return this._reference.getConnectionId(); + }, + ice_connectionId: function(id) + { + var ref = this._reference.changeConnectionId(id); + if(ref.equals(this._reference)) + { + return this; + } + else + { + return this.__newInstance(ref); + } + }, + ice_getConnection: function() + { + var __r = new AsyncResultBase(this._reference.getCommunicator(), "ice_getConnection", null, this, null); + this.__getRequestHandler().onConnection(__r); + return __r; + }, + ice_getCachedConnection: function() + { + return this._handler ? this._handler.getConnection() : null; + }, + ice_flushBatchRequests: function() + { + var __r = new ProxyBatchOutgoingAsync(this, "ice_flushBatchRequests"); + try + { + __r.__send(); + } + catch(__ex) + { + this.__handleLocalException(__r, __ex); + } + return __r; + }, + equals: function(r) + { + if(this === r) + { + return true; + } + + if(r instanceof ObjectPrx) + { + return this._reference.equals(r._reference); + } + + return false; + }, + __reference: function() + { + return this._reference; + }, + __copyFrom: function(from) + { + Debug.assert(this._reference === null); + Debug.assert(this._handler === null); + + this._reference = from._reference; + + if(this._reference.getCacheConnection()) + { + this._handler = from._handler; + } + }, + __handleException: function(handler, ex, interval, cnt) + { + if(this._handler !== null && handler._connection === this._handler._connection) + { + this._handler = null; + } + + if(cnt == -1) // Don't retry if the retry count is -1. + { + throw ex; + } + + try + { + return this._reference.getInstance().proxyFactory().checkRetryAfterException(ex, this._reference, + interval, cnt); + } + catch(e) + { + if(e instanceof Ice.CommunicatorDestroyedException) + { + // + // The communicator is already destroyed, so we cannot + // retry. + // + throw ex; + } + else + { + throw e; + } + } + }, + __handleExceptionWrapper: function(handler, ex) + { + if(this._handler !== null && handler._connection === this._handler._connection) + { + this._handler = null; + } + + if(!ex.retry) + { + throw ex.inner; + } + }, + __handleExceptionWrapperRelaxed: function(handler, ex, interval, cnt) + { + if(!ex.retry) + { + return this.__handleException(handler, ex.inner, interval, cnt); + } + else + { + if(this._handler !== null && handler._connection === this._handler._connection) + { + this._handler = null; + } + + return cnt; + } + }, + __checkAsyncTwowayOnly: function(name) + { + if(!this.ice_isTwoway()) + { + throw new Error("`" + name + "' can only be called with a twoway proxy"); + } + }, + ice_invoke: function(operation, mode, inParams, ctx, explicitCtx) + { + if(explicitCtx && ctx === null) + { + ctx = new Ice.HashMap(); + } + + var self = this; + + var completedFn = function(__res) + { + try + { + var results = []; + if((__r._state & AsyncResult.OK) === 0) + { + results.push(false); + } + else + { + results.push(true); + } + if(self._reference.getMode() === Ice.ReferenceMode.ModeTwoway) + { + results.push(__res._is.readEncaps(null)); + } + results.push(__res); + __res.succeed.apply(__res, results); + } + catch(ex) + { + ObjectPrx.__dispatchLocalException(__res, ex); + return; + } + }; + + var __r = new OutgoingAsync(this, operation, completedFn, completedFn); + + try + { + __r.__prepare(operation, mode, ctx); + __r.__writeParamEncaps(inParams); + __r.__send(); + } + catch(ex) + { + this.__handleLocalException(__r, ex); + } + return __r; + }, + __getRequestHandler: function() + { + if(this._reference.getCacheConnection()) + { + if(this._handler !== null) + { + return this._handler; + } + this._handler = this.__createRequestHandler(); + return this._handler; + } + else + { + return this.__createRequestHandler(); + } + }, + __setRequestHandler: function(handler) + { + if(this._reference.getCacheConnection()) + { + this._handler = handler; + } + }, + __createRequestHandler: function() + { + var handler = new ConnectRequestHandler(this._reference, this); + return handler.connect(); + }, + // + // Only for use by IceInternal.ProxyFactory + // + __setup: function(ref) + { + Debug.assert(this._reference === null); + + this._reference = ref; + }, + __newInstance: function(ref) + { + var proxy = new this.constructor(); + proxy.__setup(ref); + return proxy; + }, + __handleLocalException: function(__r, __ex) + { + if(__ex instanceof Ice.LocalException) + { + __r.__exception(__ex); + } + else + { + throw __ex; + } + }, + ice_instanceof: function(T) + { + if(T) + { + if(this instanceof T) + { + return true; + } + return this.constructor.__instanceof(T); + } + return false; + } + }); + + // + // Generic invocation for operations that have input parameters. + // + ObjectPrx.__invoke = function(p, name, mode, fmt, ctx, marshalFn, unmarshalFn, userEx, args) + { + if(unmarshalFn !== null || userEx.length > 0) + { + p.__checkAsyncTwowayOnly(name); + } + + var __r = new OutgoingAsync(p, name, + function(__res) + { + ObjectPrx.__completed(__res, unmarshalFn, userEx); + }); + + try + { + __r.__prepare(name, mode, ctx); + if(marshalFn === null) + { + __r.__writeEmptyParams(); + } + else + { + var __os = __r.__startWriteParams(fmt); + marshalFn.call(null, __os, args); + __r.__endWriteParams(); + } + __r.__send(); + } + catch(ex) + { + p.__handleLocalException(__r, ex); + } + return __r; + }; + + // + // Handles the completion of an invocation. + // + ObjectPrx.__completed = function(__r, unmarshalFn, userEx) + { + if(!ObjectPrx.__check(__r, userEx)) + { + return; + } + + try + { + if(unmarshalFn === null) + { + __r.__readEmptyParams(); + __r.succeed(__r); + } + else + { + var results = unmarshalFn(__r); + __r.succeed.apply(__r, results); + } + } + catch(ex) + { + ObjectPrx.__dispatchLocalException(__r, ex); + return; + } + }; + + // + // Unmarshal callback for operations that return a bool as the only result. + // + ObjectPrx.__returns_bool = function(__is, __results) + { + __results.push(__is.readBool()); + }; + + // + // Unmarshal callback for operations that return a byte as the only result. + // + ObjectPrx.__returns_byte = function(__is, __results) + { + __results.push(__is.readByte()); + }; + + // + // Unmarshal callback for operations that return a short as the only result. + // + ObjectPrx.__returns_short = function(__is, __results) + { + __results.push(__is.readShort()); + }; + + // + // Unmarshal callback for operations that return an int as the only result. + // + ObjectPrx.__returns_int = function(__is, __results) + { + __results.push(__is.readInt()); + }; + + // + // Unmarshal callback for operations that return a long as the only result. + // + ObjectPrx.__returns_long = function(__is, __results) + { + __results.push(__is.readLong()); + }; + + // + // Unmarshal callback for operations that return a float as the only result. + // + ObjectPrx.__returns_float = function(__is, __results) + { + __results.push(__is.readFloat()); + }; + + // + // Unmarshal callback for operations that return a double as the only result. + // + ObjectPrx.__returns_double = function(__is, __results) + { + __results.push(__is.readDouble()); + }; + + // + // Unmarshal callback for operations that return a string as the only result. + // + ObjectPrx.__returns_string = function(__is, __results) + { + __results.push(__is.readString()); + }; + + // + // Unmarshal callback for operations that return a proxy as the only result. + // + ObjectPrx.__returns_ObjectPrx = function(__is, __results) + { + __results.push(__is.readProxy()); + }; + + // + // Unmarshal callback for operations that return an object as the only result. + // + ObjectPrx.__returns_Object = function(__is, __results) + { + __is.readObject(function(obj){ __results.push(obj); }, Ice.Object); + __is.readPendingObjects(); + }; + + // + // Handles user exceptions. + // + ObjectPrx.__check = function(__r, __uex) + { + // + // If __uex is non-null, it must be an array of exception types. + // + try + { + __r.__throwUserException(); + } + catch(ex) + { + if(ex instanceof Ice.UserException) + { + if(__uex !== null) + { + for(var i = 0; i < __uex.length; ++i) + { + if(ex instanceof __uex[i]) + { + __r.fail(ex, __r); + return false; + } + } + } + __r.fail(new Ice.UnknownUserException(ex.ice_name()), __r); + return false; + } + else + { + __r.fail(ex, __r); + return false; + } + } + + return true; + }; + + ObjectPrx.__dispatchLocalException = function(__r, __ex) + { + __r.fail(__ex, __r); + }; + + ObjectPrx.ice_staticId = Ice.Object.ice_staticId; + + ObjectPrx.checkedCast = function(prx, facet, ctx) + { + var __r = null; + + if(prx === undefined || prx === null) + { + __r = new AsyncResultBase(null, "checkedCast", null, null, null); + __r.succeed(null, __r); + } + else + { + if(facet !== undefined) + { + prx = prx.ice_facet(facet); + } + + var __h = new this(); + __h.__copyFrom(prx); + __r = new AsyncResultBase(prx.ice_getCommunicator(), "checkedCast", null, __h, null); + prx.ice_isA(this.ice_staticId(), ctx).then( + function(__res, __ret) + { + __r.succeed(__ret ? __h : null, __r); + }).exception( + function(__ex) + { + if(__ex instanceof Ice.FacetNotExistException) + { + __r.succeed(null, __r); + } + else + { + __r.fail(__ex, __r); + } + }); + } + + return __r; + }; + + ObjectPrx.uncheckedCast = function(prx, facet) + { + var r = null; + if(prx !== undefined && prx !== null) + { + r = new this(); + if(facet !== undefined) + { + prx = prx.ice_facet(facet); + } + r.__copyFrom(prx); + } + return r; + }; + + Object.defineProperty(ObjectPrx, "minWireSize", { + get: function(){ return 2; } + }); + + ObjectPrx.write = function(os, v) + { + os.writeProxy(v); + }; + + ObjectPrx.read = function(is) + { + return is.readProxy(this); + }; + + ObjectPrx.writeOpt = function(os, tag, v) + { + os.writeOptProxy(tag, v); + }; + + ObjectPrx.readOpt = function(is, tag) + { + return is.readOptProxy(tag, this); + }; + + ObjectPrx.__instanceof = function(T) + { + if(T === this) + { + return true; + } + + for(var i in this.__implements) + { + if(this.__implements[i].__instanceof(T)) + { + return true; + } + } + + if(this.__parent) + { + return this.__parent.__instanceof(T); + } + return false; + }; + + Slice.defineProxy = function(base, staticId, prxInterfaces) + { + var prx = function() + { + base.call(this); + }; + prx.__parent = base; + prx.__implements = prxInterfaces; + + // All generated proxies inherit from ObjectPrx + prx.prototype = new base(); + prx.prototype.constructor = prx; + + // Static methods + prx.ice_staticId = staticId; + + // Copy static methods inherited from ObjectPrx + prx.checkedCast = ObjectPrx.checkedCast; + prx.uncheckedCast = ObjectPrx.uncheckedCast; + prx.write = ObjectPrx.write; + prx.writeOpt = ObjectPrx.writeOpt; + prx.read = ObjectPrx.read; + prx.readOpt = ObjectPrx.readOpt; + + prx.__instanceof = ObjectPrx.__instanceof; + + // Static properties + Object.defineProperty(prx, "minWireSize", { + get: function(){ return 2; } + }); + + return prx; + }; + + Ice.ObjectPrx = ObjectPrx; + + global.Slice = Slice; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/OpaqueEndpointI.js b/js/src/Ice/OpaqueEndpointI.js new file mode 100644 index 00000000000..32472804727 --- /dev/null +++ b/js/src/Ice/OpaqueEndpointI.js @@ -0,0 +1,446 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Base64"); + require("Ice/Debug"); + require("Ice/FormatType"); + require("Ice/HashUtil"); + require("Ice/Protocol"); + require("Ice/StringUtil"); + require("Ice/Endpoint"); + require("Ice/LocalException"); + + var Ice = global.Ice || {}; + + var Base64 = Ice.Base64; + var Debug = Ice.Debug; + var HashUtil = Ice.HashUtil; + var Protocol = Ice.Protocol; + var StringUtil = Ice.StringUtil; + + var Class = Ice.Class; + + var OpaqueEndpointI = Class(Ice.Endpoint, { + // + // Marshal the endpoint + // + streamWrite: function(s) + { + s.writeShort(this._type); + s.startWriteEncaps(this._rawEncoding, Ice.FormatType.DefaultFormat); + s.writeBlob(this._rawBytes); + s.endWriteEncaps(); + }, + // + // Convert the endpoint to its string form + // + toString: function() + { + var val = Base64.encode(this._rawBytes); + return "opaque -t " + this._type + " -e " + Ice.encodingVersionToString(this._rawEncoding) + + " -v " + val; + }, + // + // Return the endpoint information. + // + getInfo: function() + { + return new OpaqueEndpointInfoI(-1, false, this._rawEncoding, this._rawBytes, this._type); + }, + // + // Return the endpoint type + // + type: function() + { + return this._type; + }, + protocol: function() + { + return "opaque"; + }, + // + // Return the timeout for the endpoint in milliseconds. 0 means + // non-blocking, -1 means no timeout. + // + timeout: function() + { + return -1; + }, + // + // Return a new endpoint with a different timeout value, provided + // that timeouts are supported by the endpoint. Otherwise the same + // endpoint is returned. + // + changeTimeout: function(t) + { + return this; + }, + // + // Return a new endpoint with a different connection id. + // + changeConnectionId: function(connectionId) + { + return this; + }, + // + // Return true if the endpoints support bzip2 compress, or false + // otherwise. + // + compress: function() + { + return false; + }, + // + // Return a new endpoint with a different compression value, + // provided that compression is supported by the + // endpoint. Otherwise the same endpoint is returned. + // + changeCompress: function(compress) + { + return this; + }, + // + // Return true if the endpoint is datagram-based. + // + datagram: function() + { + return false; + }, + // + // Return true if the endpoint is secure. + // + secure: function() + { + return false; + }, + // + // Get the encoded endpoint. + // + rawBytes: function() + { + return this._rawBytes; // Returns a Uint8Array + }, + // + // Return a server side transceiver for this endpoint, or null if a + // transceiver can only be created by an acceptor. In case a + // transceiver is created, this operation also returns a new + // "effective" endpoint, which might differ from this endpoint, + // for example, if a dynamic port number is assigned. + // + transceiver: function(endpoint) + { + endpoint.value = null; + return null; + }, + // + // Return an acceptor for this endpoint, or null if no acceptors + // is available. In case an acceptor is created, this operation + // also returns a new "effective" endpoint, which might differ + // from this endpoint, for example, if a dynamic port number is + // assigned. + // + acceptor: function(endpoint, adapterName) + { + endpoint.value = this; + return null; + }, + connect: function() + { + return null; + }, + hashCode: function() + { + return this._hashCode; + }, + // + // Compare endpoints for sorting purposes + // + equals: function(p) + { + if(!(p instanceof OpaqueEndpointI)) + { + return false; + } + + if(this === p) + { + return true; + } + + if(this._type !== p._type) + { + return false; + } + + if(!this._rawEncoding.equals(p._rawEncoding)) + { + return false; + } + + if(this._rawBytes.length !== p._rawBytes.length) + { + return false; + } + for(var i = 0; i < this._rawBytes.length; i++) + { + if(this._rawBytes[i] !== p._rawBytes[i]) + { + return false; + } + } + + return true; + }, + compareTo: function(p) + { + if(this === p) + { + return 0; + } + + if(p === null) + { + return 1; + } + + if(!(p instanceof OpaqueEndpointI)) + { + return this.type() < p.type() ? -1 : 1; + } + + if(this._type < p._type) + { + return -1; + } + else if(p._type < this._type) + { + return 1; + } + + if(this._rawEncoding.major < p._rawEncoding.major) + { + return -1; + } + else if(p._rawEncoding.major < this._rawEncoding.major) + { + return 1; + } + + if(this._rawEncoding.minor < p._rawEncoding.minor) + { + return -1; + } + else if(p._rawEncoding.minor < this._rawEncoding.minor) + { + return 1; + } + + if(this._rawBytes.length < p._rawBytes.length) + { + return -1; + } + else if(p._rawBytes.length < this._rawBytes.length) + { + return 1; + } + for(var i = 0; i < this._rawBytes.length; i++) + { + if(this._rawBytes[i] < p._rawBytes[i]) + { + return -1; + } + else if(p._rawBytes[i] < this._rawBytes[i]) + { + return 1; + } + } + + return 0; + }, + calcHashValue: function() + { + var h = 5381; + h = HashUtil.addNumber(h, this._type); + h = HashUtil.addHashable(h, this._rawEncoding); + h = HashUtil.addArray(h, this._rawBytes, HashUtil.addNumber); + this._hashCode = h; + } + }); + + OpaqueEndpointI.fromString = function(str) + { + var result = new OpaqueEndpointI(); + + result._rawEncoding = Protocol.Encoding_1_0; + + var topt = 0; + var vopt = 0; + + var arr = str.split(/[ \t\n\r]+/); + var i = 0; + while(i < arr.length) + { + if(arr[i].length === 0) + { + i++; + continue; + } + + var option = arr[i++]; + if(option.length != 2 && option.charAt(0) != '-') + { + throw new Ice.EndpointParseException("expected an endpoint option but found `" + option + + "' in endpoint `opaque " + str + "'"); + } + + var argument = null; + if(i < arr.length && arr[i].charAt(0) != '-') + { + argument = arr[i++]; + } + + switch(option.charAt(1)) + { + case 't': + { + if(argument === null) + { + throw new Ice.EndpointParseException("no argument provided for -t option in endpoint `opaque " + + str + "'"); + } + + var type; + + try + { + type = StringUtil.toInt(argument); + } + catch(ex) + { + throw new Ice.EndpointParseException("invalid type value `" + argument + + "' in endpoint `opaque " + str + "'"); + } + + if(type < 0 || type > 65535) + { + throw new Ice.EndpointParseException("type value `" + argument + + "' out of range in endpoint `opaque " + str + "'"); + } + + result._type = type; + ++topt; + if(topt > 1) + { + throw new Ice.EndpointParseException("multiple -t options in endpoint `opaque " + str + "'"); + } + break; + } + + case 'v': + { + if(argument === null || argument.length === 0) + { + throw new Ice.EndpointParseException("no argument provided for -v option in endpoint `opaque " + + str + "'"); + } + for(var j = 0; j < argument.length; ++j) + { + if(!Base64.isBase64(argument.charAt(j))) + { + throw new Ice.EndpointParseException("invalid base64 character `" + argument.charAt(j) + + "' (ordinal " + argument.charCodeAt(j) + + ") in endpoint `opaque " + str + "'"); + } + } + result._rawBytes = Base64.decode(argument); + ++vopt; + if(vopt > 1) + { + throw new Ice.EndpointParseException("multiple -v options in endpoint `opaque " + str + "'"); + } + break; + } + + case 'e': + { + if(argument === null) + { + throw new Ice.EndpointParseException("no argument provided for -e option in endpoint `opaque " + + str + "'"); + } + try + { + result._rawEncoding = Ice.stringToEncodingVersion(argument); + } + catch(e) + { + throw new Ice.EndpointParseException("invalid encoding version `" + argument + + "' in endpoint `opaque " + str + "':\n" + e.str); + } + break; + } + + default: + { + throw new Ice.EndpointParseException("invalid option `" + option + "' in endpoint `opaque " + + str + "'"); + } + } + } + + if(topt != 1) + { + throw new Ice.EndpointParseException("no -t option in endpoint `opaque " + str + "'"); + } + if(vopt != 1) + { + throw new Ice.EndpointParseException("no -v option in endpoint `opaque " + str + "'"); + } + result.calcHashValue(); + return result; + }; + + OpaqueEndpointI.fromStream = function(type, s) + { + var result = new OpaqueEndpointI(); + result._type = type; + result._rawEncoding = s.startReadEncaps(); + var sz = s.getReadEncapsSize(); + result._rawBytes = s.readBlob(sz); + s.endReadEncaps(); + result.calcHashValue(); + return result; + }; + + Ice.OpaqueEndpointI = OpaqueEndpointI; + + var OpaqueEndpointInfoI = Class(Ice.OpaqueEndpointInfo, { + __init__: function(timeout, compress, rawEncoding, rawBytes, type) + { + Ice.OpaqueEndpointInfo.call(this, -1, false, rawEncoding, rawBytes); + this._type = type; + }, + type: function() + { + return this._type; + }, + datagram: function() + { + return false; + }, + secure: function() + { + return false; + } + }); + + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Operation.js b/js/src/Ice/Operation.js new file mode 100644 index 00000000000..11a130f542f --- /dev/null +++ b/js/src/Ice/Operation.js @@ -0,0 +1,773 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Current"); + require("Ice/DispatchStatus"); + require("Ice/Exception"); + require("Ice/FormatType"); + require("Ice/Object"); + require("Ice/ObjectPrx"); + require("Ice/OptionalFormat"); + require("Ice/StreamHelpers"); + + var Ice = global.Ice || {}; + var Slice = global.Slice || {}; + + /*jshint -W069 */ + + var Class = Ice.Class; + + var builtinHelpers = + [ + Ice.ByteHelper, + Ice.BoolHelper, + Ice.ShortHelper, + Ice.IntHelper, + Ice.LongHelper, + Ice.FloatHelper, + Ice.DoubleHelper, + Ice.StringHelper, + Ice.Object, + Ice.ObjectPrx + ]; + + function parseParam(p) + { + var type = p[0]; + var t = typeof(type); + if(t === 'number') + { + type = builtinHelpers[p[0]]; + } + else if(t === 'string') + { + /*jshint -W061 */ + type = eval(type); + /*jshint +W061 */ + } + + return { + "type": type, + "isObject": (p[1] === true), + "tag": p[2] // Optional tag, which may not be present - an undefined tag means "not optional". + }; + } + + // + // Each operation descriptor is a property. The key is the "on-the-wire" + // name, and the value is an array consisting of the following elements: + // + // 0: native method name in case of a keyword conflict (e.g., "_while"), + // otherwise an empty string + // 1: mode (undefined == Normal or int) + // 2: sendMode (undefined == Normal or int) + // 3: amd (undefined or 1) + // 4: format (undefined == Default or int) + // 5: return type (undefined if void, or [type, tag]) + // 6: in params (undefined if none, or array of [type, tag]) + // 7: out params (undefined if none, or array of [type, tag]) + // 8: exceptions (undefined if none, or array of types) + // 9: sends classes (true or undefined) + // 10: returns classes (true or undefined) + // + function parseOperation(name, arr) + { + var r = {}; + var i; + var p; + + r["name"] = name; + r["mode"] = arr[1] ? Ice.OperationMode.valueOf(arr[1]) : Ice.OperationMode.Normal; + r["sendMode"] = arr[2] ? Ice.OperationMode.valueOf(arr[2]) : Ice.OperationMode.Normal; + r["amd"] = arr[3] ? true : false; + r["format"] = arr[4] ? Ice.FormatType.valueOf(arr[4]) : Ice.FormatType.DefaultFormat; + + if(r["amd"]) + { + r["servantMethod"] = name + "_async"; + } + else + { + r["servantMethod"] = arr[0] ? arr[0] : name; + } + + var ret; + if(arr[5]) + { + ret = parseParam(arr[5]); + ret["pos"] = 0; + } + r["returns"] = ret; + + var inParams = []; + var inParamsOpt = []; + if(arr[6]) + { + for(i = 0; i < arr[6].length; ++i) + { + p = parseParam(arr[6][i]); + p["pos"] = i; + inParams.push(p); + if(p.tag) + { + inParamsOpt.push(p); + } + } + } + inParamsOpt.sort(function(p1, p2) { return p1.tag - p2.tag; }); // Sort by tag. + r["inParams"] = inParams; + r["inParamsOpt"] = inParamsOpt; + + var outParams = []; + var outParamsOpt = []; + if(arr[7]) + { + var offs = ret ? 1 : 0; + for(i = 0; i < arr[7].length; ++i) + { + p = parseParam(arr[7][i]); + p["pos"] = i + offs; + outParams.push(p); + if(p.tag) + { + outParamsOpt.push(p); + } + } + } + if(ret && ret.tag) + { + outParamsOpt.push(ret); + } + outParamsOpt.sort(function(p1, p2) { return p1.tag - p2.tag; }); // Sort by tag. + r["outParams"] = outParams; + r["outParamsOpt"] = outParamsOpt; + + var exceptions = []; + if(arr[8]) + { + for(i = 0; i < arr[8].length; ++i) + { + exceptions.push(arr[8][i]); + } + } + r["exceptions"] = exceptions; + + r["sendsClasses"] = arr[9] === true; + r["returnsClasses"] = arr[10] === true; + + return r; + } + + var OpTable = Class({ + __init__: function(ops) + { + this.raw = ops; + this.parsed = {}; + }, + find: function(name) + { + // + // Check if we've already parsed the operation. + // + var op = this.parsed[name]; + if(op === undefined && this.raw[name] !== undefined) + { + // + // We haven't parsed it yet, but we found a match for the name, so parse it now. + // + op = parseOperation(name, this.raw[name]); + this.parsed[name] = op; + } + return op; + } + }); + + function unmarshalParams(is, retvalInfo, allParamInfo, optParamInfo, usesClasses, params, offset) + { + var i, p, v; + // + // First read all required params. + // + for(i = 0; i < allParamInfo.length; ++i) + { + p = allParamInfo[i]; + if(!p.tag) + { + v = p.type.read(is); + params[p.pos + offset] = v; + } + } + + // + // Then read a required return value (if any). + // + if(retvalInfo) + { + v = retvalInfo.type.read(is); + params[retvalInfo.pos + offset] = v; + } + + // + // Then read all optional params. + // + for(i = 0; i < optParamInfo.length; ++i) + { + p = optParamInfo[i]; + v = p.type.readOpt(is, p.tag); + params[p.pos + offset] = v; + } + + if(usesClasses) + { + is.readPendingObjects(); + } + } + + function marshalParams(os, params, retvalInfo, paramInfo, optParamInfo, usesClasses) + { + var i, p; + + // + // Write the required params. + // + for(i = 0; i < paramInfo.length; ++i) + { + p = paramInfo[i]; + if(!p.tag) + { + p.type.write(os, params[p.pos]); + } + } + + // + // retvalInfo should only be provided if there is a non-void required return value. + // + if(retvalInfo) + { + retvalInfo.type.write(os, params[retvalInfo.pos]); + } + + // + // Write the optional params. + // + for(i = 0; i < optParamInfo.length; ++i) + { + p = optParamInfo[i]; + p.type.writeOpt(os, p.tag, params[p.pos]); + } + + if(usesClasses) + { + os.writePendingObjects(); + } + } + + var Upcall = Class({ + __init__: function(incomingAsync, op) + { + this.incomingAsync = incomingAsync; + this.op = op; + }, + ice_response: function() + { + var args = arguments; + + if(this.incomingAsync.__validateResponse(true)) + { + try + { + this.__sendResponse(args); + this.incomingAsync.__response(); + } + catch(ex) + { + this.incomingAsync.__exception(ex); + } + } + }, + ice_exception: function(ex) + { + if(this.__checkException(ex)) + { + if(this.incomingAsync.__validateResponse(false)) + { + this.__sendException(ex); + this.incomingAsync.__response(); + } + } + else + { + this.incomingAsync.ice_exception(ex); + } + }, + __sendResponse: function(results) + { + if(this.op.returns === undefined && this.op.outParams.length === 0) + { + if(results && results.length > 0) + { + // + // No results expected. + // + throw new Error("ice_response called with invalid arguments"); + } + else + { + this.incomingAsync.__writeEmptyParams(); + } + } + else + { + var __os = this.incomingAsync.__startWriteParams(this.op.format); + var retvalInfo; + if(this.op.returns && !this.op.returns.tag) + { + retvalInfo = this.op.returns; + } + marshalParams(__os, results, retvalInfo, this.op.outParams, this.op.outParamsOpt, + this.op.returnsClasses); + this.incomingAsync.__endWriteParams(true); + } + }, + __checkException: function(ex) + { + // + // Make sure the given exception is an instance of one of the declared user exceptions + // for this operation. + // + for(var i = 0; i < this.op.exceptions.length; ++i) + { + if(ex instanceof this.op.exceptions[i]) + { + // + // User exception is valid. + // + return true; + } + } + + return false; + }, + __sendException: function(ex) + { + // + // User exception is valid, now marshal it. + // + this.incomingAsync.__writeUserException(ex, this.op.format); + } + }); + + var __dispatchImpl = function(servant, op, incomingAsync, current) + { + // + // Check to make sure the servant implements the operation. + // + var method = servant[op.servantMethod]; + if(method === undefined || typeof(method) !== "function") + { + var comm = current.adapter.getCommunicator(); + var msg = "servant for identity " + comm.identityToString(current.id) + + " does not define operation `" + op.servantMethod + "'"; + console.log(msg); + throw new Ice.UnknownException(msg); + } + + var up = new Upcall(incomingAsync, op); + + try + { + // + // Unmarshal the in params (if any). + // + var params = op.amd ? [null] : []; + if(op.inParams.length === 0) + { + incomingAsync.readEmptyParams(); + } + else + { + var __is = incomingAsync.startReadParams(); + var offset = op.amd ? 1 : 0; + unmarshalParams(__is, undefined, op.inParams, op.inParamsOpt, op.sendsClasses, params, offset); + incomingAsync.endReadParams(); + + // + // When unmarshaling objects, the ObjectHelper returns a wrapper object + // and eventually stores the unmarshaled object into its "value" member. + // Here we scan the parameter array and replace the wrappers with the + // actual object references. + // + if(op.inParams.length > 0 && (op.sendsClasses || op.inParamsOpt.length > 0)) + { + for(var i = 0; i < op.inParams.length; ++i) + { + var p = op.inParams[i]; + // + // Optional parameters may be undefined. + // + if(p.isObject && params[p.pos + offset] !== undefined) + { + params[p.pos + offset] = params[p.pos + offset].value; + } + } + } + } + + params.push(current); + + if(op.amd) + { + params[0] = up; // The AMD callback object. + try + { + method.apply(servant, params); + } + catch(ex) + { + up.ice_exception(ex); + } + return Ice.DispatchStatus.DispatchAsync; + } + else + { + // + // Determine how many out parameters to expect. + // + var numExpectedResults = op.outParams.length; + if(op.returns) + { + ++numExpectedResults; + } + + var results = method.apply(servant, params); + + // + // Complain if we expect more than out parameter and the servant doesn't return an array. + // + if(numExpectedResults > 1 && !(results instanceof Array)) + { + var msg = "operation `" + op.servantMethod + "' should return an array of length " + numParams; + console.log(msg); + throw new Ice.MarshalException(msg); + } + else if(numExpectedResults === 1) + { + // + // Wrap a single out parameter in an array. + // + results = [results]; + } + + up.__sendResponse(results); + return Ice.DispatchStatus.DispatchOK; + } + } + catch(ex) + { + if(up.__checkException(ex)) + { + up.__sendException(ex); + return Ice.DispatchStatus.DispatchUserException; + } + else + { + throw ex; + } + } + }; + + function getServantMethodFromInterfaces(interfaces, methodName, all) + { + var method; + for(var i = 0; method === undefined && i < interfaces.length; ++i) + { + var intf = interfaces[i]; + method = intf[methodName]; + if(method === undefined) + { + if(all.indexOf(intf) === -1) + { + all.push(intf); + } + if(intf.__implements) + { + method = getServantMethodFromInterfaces(intf.__implements, methodName, all); + } + } + } + return method; + } + + var dispatchPrefix = "__op_"; + + function getServantMethod(servantType, name) + { + // + // The dispatch method is named __op_<Slice name> and is stored in the type (not the prototype). + // + var methodName = dispatchPrefix + name; + + // + // First check the servant type. + // + var method = servantType[methodName]; + + var allInterfaces; + + if(method === undefined) + { + allInterfaces = []; + + // + // Now check the prototypes of the implemented interfaces. + // + var curr = servantType; + while(curr && method === undefined) + { + if(curr.__implements) + { + method = getServantMethodFromInterfaces(curr.__implements, methodName, allInterfaces); + } + curr = curr.__parent; + } + + if(method !== undefined) + { + // + // Add the method to the servant's type. + // + servantType[methodName] = method; + } + } + + if(method === undefined) + { + // + // Next check the op table for the servant's type. + // + var op; + if(servantType.__ops) + { + op = servantType.__ops.find(name); + } + + var source; + if(op === undefined) + { + // + // Now check the op tables of the base types. + // + var parent = servantType.__parent; + while(op === undefined && parent) + { + if(parent.__ops) + { + if((op = parent.__ops.find(name)) !== undefined) + { + source = parent; + } + } + parent = parent.__parent; + } + + // + // Now check the op tables of all base interfaces. + // + for(var i = 0; op === undefined && i < allInterfaces.length; ++i) + { + var intf = allInterfaces[i]; + if(intf.__ops) + { + if((op = intf.__ops.find(name)) !== undefined) + { + source = intf; + } + } + } + } + + if(op !== undefined) + { + method = function(servant, incomingAsync, current) + { + return __dispatchImpl(servant, op, incomingAsync, current); + }; + + // + // Add the method to the servant type. + // + servantType[methodName] = method; + + // + // Also add the method to the type in which the operation was found. + // + if(source) + { + source[methodName] = method; + } + } + } + + return method; + } + + function addProxyOperation(proxyType, name, data) + { + var method = data[0] ? data[0] : name; + + var op = null; + + proxyType.prototype[method] = function() + { + var args = arguments; + + // + // Parse the operation data on the first invocation of a proxy method. + // + if(op === null) + { + op = parseOperation(name, data); + } + + var ctx = args[op.inParams.length]; // The request context is the last argument (if present). + + var marshalFn = null; + if(op.inParams.length > 0) + { + marshalFn = function(os, params) + { + marshalParams(os, params, undefined, op.inParams, op.inParamsOpt, op.sendsClasses); + }; + } + + var unmarshalFn = null; + if(op.returns || op.outParams.length > 0) + { + unmarshalFn = function(asyncResult) + { + // + // The results array holds the out parameters in the following format: + // + // [retval, out1, out2, ..., asyncResult] + // + var results = []; + + var is = asyncResult.__startReadParams(); + + var retvalInfo; + if(op.returns && !op.returns.tag) + { + retvalInfo = op.returns; + } + unmarshalParams(is, retvalInfo, op.outParams, op.outParamsOpt, op.returnsClasses, results, 0); + + asyncResult.__endReadParams(); + + // + // When unmarshaling objects, the ObjectHelper returns a wrapper object + // and eventually stores the unmarshaled object into its "value" member. + // Here we scan the results array and replace the wrappers with the + // actual object references. + // + if(op.returnsClasses || op.outParamsOpt.length > 0) + { + var offset = 0; // Skip asyncResult in results. + if(op.returns && op.returns.isObject && results[op.returns.pos + offset] !== undefined) + { + results[op.returns.pos + offset] = results[op.returns.pos + offset].value; + } + for(var i = 0; i < op.outParams.length; ++i) + { + var p = op.outParams[i]; + // + // Optional parameters may be undefined. + // + if(p.isObject && results[p.pos + offset] !== undefined) + { + results[p.pos + offset] = results[p.pos + offset].value; + } + } + } + results.push(asyncResult); + return results; + }; + } + + return Ice.ObjectPrx.__invoke(this, op.name, op.sendMode, op.format, ctx, marshalFn, unmarshalFn, + op.exceptions, Array.prototype.slice.call(args)); + }; + } + + Slice.defineOperations = function(classType, proxyType, ops) + { + if(ops) + { + classType.__ops = new OpTable(ops); + } + + classType.prototype.__dispatch = function(incomingAsync, current) + { + // + // Retrieve the dispatch method for this operation. + // + var method = getServantMethod(classType, current.operation); + + if(method === undefined || typeof(method) !== 'function') + { + throw new Ice.OperationNotExistException(current.id, current.facet, current.operation); + } + + return method.call(method, this, incomingAsync, current); + }; + + if(ops) + { + for(var name in ops) + { + addProxyOperation(proxyType, name, ops[name]); + } + } + + // + // Copy proxy methods from super-interfaces. + // + if(proxyType.__implements) + { + for(var intf in proxyType.__implements) + { + var proto = proxyType.__implements[intf].prototype; + for(var f in proto) + { + if(typeof proto[f] == "function" && proxyType.prototype[f] === undefined) + { + proxyType.prototype[f] = proto[f]; + } + } + } + } + }; + + // + // Define the "built-in" operations for all Ice objects. + // + Slice.defineOperations(Ice.Object, Ice.ObjectPrx, + { + "ice_ping": [, 1, 1, , , , , , ], + "ice_isA": [, 1, 1, , , [1], [[7]], , ], + "ice_id": [, 1, 1, , , [7], , , ], + "ice_ids": [, 1, 1, , , ["Ice.StringSeqHelper"], , , ] + }); + + global.Slice = Slice; + global.Ice = Ice; + + /*jshint +W069 */ +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/OptionalFormat.js b/js/src/Ice/OptionalFormat.js new file mode 100644 index 00000000000..6e3f866ee66 --- /dev/null +++ b/js/src/Ice/OptionalFormat.js @@ -0,0 +1,19 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/EnumBase"); + + var Ice = global.Ice || {}; + + Ice.OptionalFormat = Slice.defineEnum( + {'F1':0, 'F2':1, 'F4':2, 'F8':3, 'Size':4, 'VSize':5, 'FSize':6, 'Class':7}); + + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/OutgoingAsync.js b/js/src/Ice/OutgoingAsync.js new file mode 100644 index 00000000000..ec72d35e436 --- /dev/null +++ b/js/src/Ice/OutgoingAsync.js @@ -0,0 +1,572 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_FOR_ACTIONSCRIPT_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/AsyncStatus"); + require("Ice/AsyncResult"); + require("Ice/BasicStream"); + require("Ice/Debug"); + require("Ice/HashMap"); + require("Ice/LocalExceptionWrapper"); + require("Ice/Current"); + require("Ice/Protocol"); + require("Ice/BuiltinSequences"); + require("Ice/Exception"); + require("Ice/LocalException"); + require("Ice/Identity"); + + var Ice = global.Ice || {}; + + var AsyncStatus = Ice.AsyncStatus; + var AsyncResult = Ice.AsyncResult; + var BasicStream = Ice.BasicStream; + var Debug = Ice.Debug; + var HashMap = Ice.HashMap; + var LocalExceptionWrapper = Ice.LocalExceptionWrapper; + var OperationMode = Ice.OperationMode; + var Protocol = Ice.Protocol; + var Identity = Ice.Identity; + + var OutgoingAsync = Ice.Class(AsyncResult, { + __init__: function(prx, operation, completed, sent) + { + // + // OutgoingAsync can be constructed by a sub-type's prototype, in which case the + // arguments are undefined. + // + if(prx !== undefined) + { + AsyncResult.call(this, prx.ice_getCommunicator(), operation, null, prx, null, completed, sent); + this._batch = this._proxy.ice_isBatchOneway() || this._proxy.ice_isBatchDatagram(); + + this._batchStarted = false; + + this._timerToken = -1; + this._timerConnection = null; + + this._handler = null; + this._encoding = Protocol.getCompatibleEncoding(this._proxy.__reference().getEncoding()); + this._cnt = 0; + this._mode = null; + } + else + { + AsyncResult.call(this); + } + }, + __prepare: function(op, mode, ctx) + { + this._handler = null; + this._cnt = 0; + this._mode = mode; + + Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(this._proxy.__reference().getProtocol())); + + if(ctx === null) + { + ctx = OutgoingAsync._emptyContext; + } + + if(this._batch) + { + while(true) + { + try + { + this._handler = this._proxy.__getRequestHandler(); + this._handler.prepareBatchRequest(this._os); + this._batchStarted = true; + break; + } + catch(ex) + { + if(ex instanceof LocalExceptionWrapper) + { + this.handleExceptionWrapper(ex); + } + else if(ex instanceof Ice.LocalException) + { + this.handleException(ex, false); + } + else + { + throw ex; + } + } + } + } + else + { + this._os.writeBlob(Protocol.requestHdr); + } + + var ref = this._proxy.__reference(); + + ref.getIdentity().__write(this._os); + + // + // For compatibility with the old FacetPath. + // + var facet = ref.getFacet(); + if(facet === null || facet.length === 0) + { + Ice.StringSeqHelper.write(this._os, null); + } + else + { + Ice.StringSeqHelper.write(this._os, [ facet ]); + } + + this._os.writeString(this._operation); + + this._os.writeByte(mode.value); + + if(ctx !== undefined) + { + if(ctx !== null && !(ctx instanceof HashMap)) + { + throw new Error("illegal context value, expecting null or HashMap"); + } + + // + // Explicit context + // + Ice.ContextHelper.write(this._os, ctx); + } + else + { + // + // Implicit context + // + var implicitContext = ref.getInstance().getImplicitContext(); + var prxContext = ref.getContext(); + + if(implicitContext === null) + { + Ice.ContextHelper.write(this._os, prxContext); + } + else + { + implicitContext.write(prxContext, this._os); + } + } + }, + __sent: function(connection) + { + this._state |= AsyncResult.Sent; + + if((this._state & AsyncResult.Done) === 0) + { + if(!this._proxy.ice_isTwoway()) + { + this._state |= AsyncResult.Done | AsyncResult.OK; + this._os.resize(0); + if(this._sent) + { + this._sent.call(null, this); + } + else + { + this.succeed(this); + } + } + else if(connection.timeout() > 0) + { + Debug.assert(this._timerToken === -1); + this._timerConnection = connection; + var self = this; + this._timerToken = this._instance.timer().schedule( + function() { self.__runTimerTask(); }, connection.timeout()); + } + } + }, + __finishedEx: function(exc, sent) + { + Debug.assert((this._state & AsyncResult.Done) === 0); + if(this._timerConnection !== null) + { + this._instance.timer().cancel(this._timerToken); + this._timerConnection = null; + this._timerToken = -1; + } + + try + { + var interval = this.handleException(exc, sent); // This will throw if the invocation can't be retried. + if(interval > 0) + { + this._instance.retryQueue().add(this, interval); + } + else + { + this.__send(); + } + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.__exception(ex); + } + else + { + this.fail(ex, this); + } + } + }, + __finishedWrapper: function(exc) + { + // + // The LocalExceptionWrapper exception is only called before the invocation is sent. + // + + try + { + var interval = this.handleExceptionWrapper(exc); // This will throw if the invocation can't be retried. + if(interval > 0) + { + this._instance.retryQueue().add(this, interval); + } + else + { + this.__send(); + } + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.__exception(ex); + } + else + { + this.fail(ex, this); + } + } + }, + __finished: function(istr) + { + Debug.assert(this._proxy.ice_isTwoway()); // Can only be called for twoways. + + var replyStatus; + try + { + Debug.assert(this._exception === null && (this._state & AsyncResult.Done) === 0); + + if(this._timerConnection !== null) + { + Debug.assert(this._timerToken !== -1); + this._instance.timer().cancel(this._timerToken); + this._timerConnection = null; + this._timerToken = -1; + } + + if(this._is === null) // _is can already be initialized if the invocation is retried + { + this._is = new BasicStream(this._instance, Protocol.currentProtocolEncoding, false); + } + this._is.swap(istr); + replyStatus = this._is.readByte(); + + switch(replyStatus) + { + case Protocol.replyOK: + case Protocol.replyUserException: + { + break; + } + + case Protocol.replyObjectNotExist: + case Protocol.replyFacetNotExist: + case Protocol.replyOperationNotExist: + { + var id = new Identity(); + id.__read(this._is); + + // + // For compatibility with the old FacetPath. + // + var facetPath = Ice.StringSeqHelper.read(this._is); + var facet; + if(facetPath.length > 0) + { + if(facetPath.length > 1) + { + throw new Ice.MarshalException(); + } + facet = facetPath[0]; + } + else + { + facet = ""; + } + + var operation = this._is.readString(); + + var rfe = null; + switch(replyStatus) + { + case Protocol.replyObjectNotExist: + { + rfe = new Ice.ObjectNotExistException(); + break; + } + + case Protocol.replyFacetNotExist: + { + rfe = new Ice.FacetNotExistException(); + break; + } + + case Protocol.replyOperationNotExist: + { + rfe = new Ice.OperationNotExistException(); + break; + } + + default: + { + Debug.assert(false); + break; + } + } + + rfe.id = id; + rfe.facet = facet; + rfe.operation = operation; + throw rfe; + } + + case Protocol.replyUnknownException: + case Protocol.replyUnknownLocalException: + case Protocol.replyUnknownUserException: + { + var unknown = this._is.readString(); + + var ue = null; + switch(replyStatus) + { + case Protocol.replyUnknownException: + { + ue = new Ice.UnknownException(); + break; + } + + case Protocol.replyUnknownLocalException: + { + ue = new Ice.UnknownLocalException(); + break; + } + + case Protocol.replyUnknownUserException: + { + ue = new Ice.UnknownUserException(); + break; + } + + default: + { + Debug.assert(false); + break; + } + } + + ue.unknown = unknown; + throw ue; + } + + default: + { + throw new Ice.UnknownReplyStatusException(); + } + } + + this._state |= AsyncResult.Done; + if(replyStatus == Protocol.replyOK) + { + this._state |= AsyncResult.OK; + } + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + this.__finishedEx(ex, true); + return; + } + else + { + this.fail(ex, this); + return; + } + } + + Debug.assert(replyStatus === Protocol.replyOK || replyStatus === Protocol.replyUserException); + this.__response(); + }, + __send: function() + { + if(this._batch) + { + Debug.assert(this._handler !== null); + this._handler.finishBatchRequest(this._os); + this.succeed(this); + } + else + { + while(true) + { + var interval = 0; + try + { + this._handler = this._proxy.__getRequestHandler(); + this._handler.sendAsyncRequest(this); + break; + } + catch(ex) + { + if(ex instanceof LocalExceptionWrapper) + { + interval = this.handleExceptionWrapper(ex); + } + else if(ex instanceof Ice.LocalException) + { + interval = this.handleException(ex, false); + } + else + { + throw ex; + } + } + + if(interval > 0) + { + this._instance.retryQueue().add(this, interval); + return false; + } + } + } + }, + __startWriteParams: function(format) + { + this._os.startWriteEncaps(this._encoding, format); + return this._os; + }, + __endWriteParams: function() + { + this._os.endWriteEncaps(); + }, + __writeEmptyParams: function() + { + this._os.writeEmptyEncaps(this._encoding); + }, + __writeParamEncaps: function(encaps) + { + if(encaps === null || encaps.length === 0) + { + this._os.writeEmptyEncaps(this._encoding); + } + else + { + this._os.writeEncaps(encaps); + } + }, + __exception: function(ex) + { + AsyncResult.prototype.__exception.call(this, ex); + + if(this._batchStarted) + { + Debug.assert(this._handler !== null); + this._handler.abortBatchRequest(); + } + }, + handleException: function(exc, sent) + { + var interval = { value: 0 }; + try + { + // + // A CloseConnectionException indicates graceful server shutdown, and is therefore + // always repeatable without violating "at-most-once". That's because by sending a + // close connection message, the server guarantees that all outstanding requests + // can safely be repeated. + // + // An ObjectNotExistException can always be retried as well without violating + // "at-most-once" (see the implementation of the checkRetryAfterException method of + // the ProxyFactory class for the reasons why it can be useful). + // + if(!sent || exc instanceof Ice.CloseConnectionException || exc instanceof Ice.ObjectNotExistException) + { + throw exc; + } + + // + // Throw the exception wrapped in a LocalExceptionWrapper, to indicate that the + // request cannot be resent without potentially violating the "at-most-once" + // principle. + // + throw new LocalExceptionWrapper(exc, false); + } + catch(ex) + { + if(ex instanceof LocalExceptionWrapper) + { + if(this._mode === OperationMode.Nonmutating || this._mode === OperationMode.Idempotent) + { + this._cnt = this._proxy.__handleExceptionWrapperRelaxed(this._handler, ex, interval, this._cnt); + } + else + { + this._proxy.__handleExceptionWrapper(this._handler, ex); + } + } + else if(ex instanceof Ice.LocalException) + { + this._cnt = this._proxy.__handleException(this._handler, ex, interval, this._cnt); + } + else + { + throw ex; + } + } + return interval.value; + }, + handleExceptionWrapper: function(ex) + { + var interval = { value: 0 }; + if(this._mode === OperationMode.Nonmutating || this._mode === OperationMode.Idempotent) + { + this._cnt = this._proxy.__handleExceptionWrapperRelaxed(this._handler, ex, interval, this._cnt); + } + else + { + this._proxy.__handleExceptionWrapper(this._handler, ex); + } + return interval.value; + }, + __runTimerTask: function() + { + var connection = this._timerConnection; + this._timerConnection = null; + this._timerToken = -1; + + if(connection !== null) + { + connection.exception(new Ice.TimeoutException()); + } + } + }); + + OutgoingAsync._emptyContext = new HashMap(); + + Ice.OutgoingAsync = OutgoingAsync; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/OutgoingConnectionFactory.js b/js/src/Ice/OutgoingConnectionFactory.js new file mode 100644 index 00000000000..6399b6ea5b4 --- /dev/null +++ b/js/src/Ice/OutgoingConnectionFactory.js @@ -0,0 +1,956 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/ArrayUtil"); + require("Ice/AsyncResultBase"); + require("Ice/ConnectionI"); + require("Ice/ConnectionReaper"); + require("Ice/Debug"); + require("Ice/ExUtil"); + require("Ice/HashMap"); + require("Ice/Promise"); + require("Ice/EndpointTypes"); + require("Ice/LocalException"); + require("Ice/Exception"); + + var Ice = global.Ice || {}; + + var ArrayUtil = Ice.ArrayUtil; + var AsyncResultBase = Ice.AsyncResultBase; + var ConnectionI = Ice.ConnectionI; + var ConnectionReaper = Ice.ConnectionReaper; + var Debug = Ice.Debug; + var ExUtil = Ice.ExUtil; + var HashMap = Ice.HashMap; + var Promise = Ice.Promise; + var EndpointSelectionType = Ice.EndpointSelectionType; + + var Class = Ice.Class; + // + // Only for use by Instance. + // + var OutgoingConnectionFactory = Class({ + __init__: function(communicator, instance) + { + this._communicator = communicator; + this._instance = instance; + this._destroyed = false; + + this._reaper = new ConnectionReaper(); + + this._connectionsByEndpoint = new ConnectionListMap(); // map<EndpointI, Array<Ice.ConnectionI>> + this._pending = new HashMap(); // map<EndpointI, Array<ConnectCallback>> + this._pending.keyComparator = HashMap.compareEquals; + this._pendingConnectCount = 0; + + this._waitPromise = null; + }, + destroy: function() + { + if(this._destroyed) + { + return; + } + + this._connectionsByEndpoint.forEach(function(connection) + { + connection.destroy(ConnectionI.CommunicatorDestroyed); + }); + + this._destroyed = true; + this._communicator = null; + this.checkFinished(); + }, + waitUntilFinished: function() + { + this._waitPromise = new Promise(); + this.checkFinished(); + return this._waitPromise; + }, + // + // Returns a promise, success callback receives (connection, compress) + // + create: function(endpts, hasMore, selType) + { + Debug.assert(endpts.length > 0); + + // + // Apply the overrides. + // + var endpoints = this.applyOverrides(endpts); + + // + // Try to find a connection to one of the given endpoints. + // + try + { + var compress = { value: false }; + var connection = this.findConnectionByEndpoint(endpoints, compress); + if(connection !== null) + { + return new Promise().succeed(connection, compress.value); + } + } + catch(ex) + { + return new Promise().fail(ex); + } + + var cb = new ConnectCallback(this, endpoints, hasMore, selType); + return cb.start(); + }, + setRouterInfo: function(routerInfo) + { + var self = this; + return Ice.Promise.try( + function() + { + if(self._destroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + return routerInfo.getClientEndpoints(); + } + ).then( + function(endpoints) + { + // + // Search for connections to the router's client proxy + // endpoints, and update the object adapter for such + // connections, so that callbacks from the router can be + // received over such connections. + // + var adapter = routerInfo.getAdapter(); + var defaultsAndOverrides = self._instance.defaultsAndOverrides(); + for(var i = 0; i < endpoints.length; ++i) + { + var endpoint = endpoints[i]; + + // + // Modify endpoints with overrides. + // + if(defaultsAndOverrides.overrideTimeout) + { + endpoint = endpoint.changeTimeout(defaultsAndOverrides.overrideTimeoutValue); + } + + // + // The Connection object does not take the compression flag of + // endpoints into account, but instead gets the information + // about whether messages should be compressed or not from + // other sources. In order to allow connection sharing for + // endpoints that differ in the value of the compression flag + // only, we always set the compression flag to false here in + // this connection factory. + // + endpoint = endpoint.changeCompress(false); + + self._connectionsByEndpoint.forEach(function(connection) + { + if(connection.endpoint().equals(endpoint)) + { + connection.setAdapter(adapter); + } + }); + } + } + ); + }, + removeAdapter: function(adapter) + { + if(this._destroyed) + { + return; + } + this._connectionsByEndpoint.forEach(function(connection) + { + if(connection.getAdapter() === adapter) + { + connection.setAdapter(null); + } + }); + }, + flushAsyncBatchRequests: function() + { + var promise = new AsyncResultBase(this._communicator, "flushBatchRequests", null, null, null); + if(this._destroyed) + { + promise.succeed(); + return; + } + + Promise.all( + this._connectionsByEndpoint.map( + function(connection) + { + if(connection.isActiveOrHolding()) + { + return connection.flushBatchRequests().exception( + function(ex) + { + if(ex instanceof Ice.LocalException) + { + // Ignore + } + else + { + throw ex; + } + }); + } + }) + ).then( + function() + { + promise.succeed(promise); + }, + function(ex) + { + promise.fail(ex, promise); + } + ); + return promise; + }, + applyOverrides: function(endpts) + { + var defaultsAndOverrides = this._instance.defaultsAndOverrides(); + var endpoints = []; + for(var i = 0; i < endpts.length; ++i) + { + var endpoint = endpts[i]; + + // + // Modify endpoints with overrides. + // + if(defaultsAndOverrides.overrideTimeout) + { + endpoints.push(endpoint.changeTimeout(defaultsAndOverrides.overrideTimeoutValue)); + } + else + { + endpoints.push(endpoint); + } + } + + return endpoints; + }, + findConnectionByEndpoint: function(endpoints, compress) + { + if(this._destroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + var defaultsAndOverrides = this._instance.defaultsAndOverrides(); + Debug.assert(endpoints.length > 0); + + for(var i = 0; i < endpoints.length; ++i) + { + var endpoint = endpoints[i]; + + if(this._pending.has(endpoint)) + { + continue; + } + + var connectionList = this._connectionsByEndpoint.get(endpoint); + if(connectionList === undefined) + { + continue; + } + + for(var j = 0; j < connectionList.length; ++j) + { + if(connectionList[j].isActiveOrHolding()) // Don't return destroyed or un-validated connections + { + if(defaultsAndOverrides.overrideCompress) + { + compress.value = defaultsAndOverrides.overrideCompressValue; + } + else + { + compress.value = endpoint.compress(); + } + return connectionList[j]; + } + } + } + + return null; + }, + incPendingConnectCount: function() + { + // + // Keep track of the number of pending connects. The outgoing connection factory + // waitUntilFinished() method waits for all the pending connects to terminate before + // to return. This ensures that the communicator client thread pool isn't destroyed + // too soon and will still be available to execute the ice_exception() callbacks for + // the asynchronous requests waiting on a connection to be established. + // + + if(this._destroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + ++this._pendingConnectCount; + }, + decPendingConnectCount: function() + { + --this._pendingConnectCount; + Debug.assert(this._pendingConnectCount >= 0); + if(this._destroyed && this._pendingConnectCount === 0) + { + this.checkFinished(); + } + }, + getConnection: function(endpoints, cb, compress) + { + if(this._destroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + // + // Reap closed connections + // + var cons = this._reaper.swapConnections(); + if(cons !== null) + { + for(var i = 0; i < cons.length; ++i) + { + var c = cons[i]; + this._connectionsByEndpoint.removeConnection(c.endpoint(), c); + this._connectionsByEndpoint.removeConnection(c.endpoint().changeCompress(true), c); + } + } + + // + // Try to get the connection. + // + while(true) + { + if(this._destroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + // + // Search for a matching connection. If we find one, we're done. + // + var connection = this.findConnectionByEndpoint(endpoints, compress); + if(connection !== null) + { + return connection; + } + + if(this.addToPending(cb, endpoints)) + { + // + // A connection is already pending. + // + return null; + } + else + { + // + // No connection is currently pending to one of our endpoints, so we + // get out of this loop and start the connection establishment to one of the + // given endpoints. + // + break; + } + } + + // + // At this point, we're responsible for establishing the connection to one of + // the given endpoints. If it's a non-blocking connect, calling nextEndpoint + // will start the connection establishment. Otherwise, we return null to get + // the caller to establish the connection. + // + cb.nextEndpoint(); + + return null; + }, + createConnection: function(transceiver, endpoint) + { + Debug.assert(this._pending.has(endpoint) && transceiver !== null); + + // + // Create and add the connection to the connection map. Adding the connection to the map + // is necessary to support the interruption of the connection initialization and validation + // in case the communicator is destroyed. + // + var connection = null; + try + { + if(this._destroyed) + { + throw new Ice.CommunicatorDestroyedException(); + } + + connection = new ConnectionI(this._communicator, this._instance, this._reaper, transceiver, + endpoint.changeCompress(false), false, null); + } + catch(ex) + { + if(ex instanceof Ice.LocalException) + { + try + { + transceiver.close(); + } + catch(exc) + { + // Ignore + } + } + throw ex; + } + + this._connectionsByEndpoint.set(connection.endpoint(), connection); + this._connectionsByEndpoint.set(connection.endpoint().changeCompress(true), connection); + return connection; + }, + finishGetConnection: function(endpoints, endpoint, connection, cb) + { + // cb is-a ConnectCallback + + var connectionCallbacks = []; + if(cb !== null) + { + connectionCallbacks.push(cb); + } + + var i; + var cc; + var callbacks = []; + for(i = 0; i < endpoints.length; ++i) + { + var endpt = endpoints[i]; + var cbs = this._pending.get(endpt); + if(cbs !== undefined) + { + this._pending.delete(endpt); + for(var j = 0; j < cbs.length; ++j) + { + cc = cbs[j]; + if(cc.hasEndpoint(endpoint)) + { + if(connectionCallbacks.indexOf(cc) === -1) + { + connectionCallbacks.push(cc); + } + } + else + { + if(callbacks.indexOf(cc) === -1) + { + callbacks.push(cc); + } + } + } + } + } + + for(i = 0; i < connectionCallbacks.length; ++i) + { + cc = connectionCallbacks[i]; + cc.removeFromPending(); + var idx = callbacks.indexOf(cc); + if(idx !== -1) + { + callbacks.splice(idx, 1); + } + } + for(i = 0; i < callbacks.length; ++i) + { + cc = callbacks[i]; + cc.removeFromPending(); + } + + var compress; + var defaultsAndOverrides = this._instance.defaultsAndOverrides(); + if(defaultsAndOverrides.overrideCompress) + { + compress = defaultsAndOverrides.overrideCompressValue; + } + else + { + compress = endpoint.compress(); + } + + for(i = 0; i < callbacks.length; ++i) + { + cc = callbacks[i]; + cc.getConnection(); + } + for(i = 0; i < connectionCallbacks.length; ++i) + { + cc = connectionCallbacks[i]; + cc.setConnection(connection, compress); + } + + this.checkFinished(); + }, + finishGetConnectionEx: function(endpoints, ex, cb) + { + // cb is-a ConnectCallback + + var failedCallbacks = []; + if(cb !== null) + { + failedCallbacks.push(cb); + } + var i; + var cc; + var callbacks = []; + for(i = 0; i < endpoints.length; ++i) + { + var endpt = endpoints[i]; + var cbs = this._pending.get(endpt); + if(cbs !== undefined) + { + this._pending.delete(endpt); + for(var j = 0; j < cbs.length; ++j) + { + cc = cbs[j]; + if(cc.removeEndpoints(endpoints)) + { + if(failedCallbacks.indexOf(cc) === -1) + { + failedCallbacks.push(cc); + } + } + else + { + if(callbacks.indexOf(cc) === -1) + { + callbacks.push(cc); + } + } + } + } + } + + for(i = 0; i < callbacks.length; ++i) + { + cc = callbacks[i]; + Debug.assert(failedCallbacks.indexOf(cc) === -1); + cc.removeFromPending(); + } + this.checkFinished(); + + for(i = 0; i < callbacks.length; ++i) + { + cc = callbacks[i]; + cc.getConnection(); + } + for(i = 0; i < failedCallbacks.length; ++i) + { + cc = failedCallbacks[i]; + cc.setException(ex); + } + }, + addToPending: function(cb, endpoints) + { + // cb is-a ConnectCallback + + // + // Add the callback to each pending list. + // + var found = false; + var p; + var i; + if(cb !== null) + { + for(i = 0; i < endpoints.length; ++i) + { + p = endpoints[i]; + var cbs = this._pending.get(p); + if(cbs !== undefined) + { + found = true; + if(cbs.indexOf(cb) === -1) + { + cbs.push(cb); // Add the callback to each pending endpoint. + } + } + } + } + + if(found) + { + return true; + } + + // + // If there's no pending connection for the given endpoints, we're + // responsible for its establishment. We add empty pending lists, + // other callbacks to the same endpoints will be queued. + // + for(i = 0; i < endpoints.length; ++i) + { + p = endpoints[i]; + if(!this._pending.has(p)) + { + this._pending.set(p, []); + } + } + + return false; + }, + removeFromPending: function(cb, endpoints) + { + // cb is-a ConnectCallback + + for(var i = 0; i < endpoints.length; ++i) + { + var p = endpoints[i]; + var cbs = this._pending.get(p); + if(cbs !== undefined) + { + var idx = cbs.indexOf(cb); + if(idx !== -1) + { + cbs.splice(idx, 1); + } + } + } + }, + handleConnectionException: function(ex, hasMore) + { + var traceLevels = this._instance.traceLevels(); + if(traceLevels.retry >= 2) + { + var s = []; + s.push("connection to endpoint failed"); + if(ex instanceof Ice.CommunicatorDestroyedException) + { + s.push("\n"); + } + else + { + if(hasMore) + { + s.push(", trying next endpoint\n"); + } + else + { + s.push(" and no more endpoints to try\n"); + } + } + s.push(ExUtil.toString(ex)); + this._instance.initializationData().logger.trace(traceLevels.retryCat, s.join("")); + } + }, + handleException: function(ex, hasMore) + { + var traceLevels = this._instance.traceLevels(); + if(traceLevels.retry >= 2) + { + var s = []; + s.push("couldn't resolve endpoint host"); + if(ex instanceof Ice.CommunicatorDestroyedException) + { + s.push("\n"); + } + else + { + if(hasMore) + { + s.push(", trying next endpoint\n"); + } + else + { + s.push(" and no more endpoints to try\n"); + } + } + s.push(ExUtil.toString(ex)); + this._instance.initializationData().logger.trace(traceLevels.retryCat, s.join("")); + } + }, + checkFinished: function() + { + // + // Can't continue until the factory is destroyed and there are no pending connections. + // + if(!this._waitPromise || !this._destroyed || this._pending.size > 0 || this._pendingConnectCount > 0) + { + return; + } + + var self = this; + Promise.all( + self._connectionsByEndpoint.map( + function(connection) + { + return connection.waitUntilFinished().exception(function(ex) + { + Debug.assert(false); + }); + } + ) + ).then( + function() + { + var cons = self._reaper.swapConnections(); + if(cons !== null) + { + var arr = []; + for(var e = self._connectionsByEndpoint.entries; e !== null; e = e.next) + { + var connectionList = e.value; + for(var i = 0; i < connectionList.length; ++i) + { + if(arr.indexOf(connectionList[i]) === -1) + { + arr.push(connectionList[i]); + } + } + } + Debug.assert(cons.length === arr.length); + self._connectionsByEndpoint.clear(); + } + else + { + Debug.assert(self._connectionsByEndpoint.size === 0); + } + + Debug.assert(self._waitPromise !== null); + self._waitPromise.succeed(); + } + ); + } + }); + + Ice.OutgoingConnectionFactory = OutgoingConnectionFactory; + global.Ice = Ice; + + // + // Value is a Vector<Ice.ConnectionI> + // + var ConnectionListMap = Class(HashMap, { + __init__: function(h) + { + HashMap.call(this, h); + this.keyComparator = HashMap.compareEquals; + }, + set: function(key, value) + { + var list = this.get(key); + if(list === undefined) + { + list = []; + HashMap.prototype.set.call(this, key, list); + } + Debug.assert(value instanceof ConnectionI); + list.push(value); + return undefined; + }, + removeConnection: function(key, conn) + { + var list = this.get(key); + Debug.assert(list !== null); + var idx = list.indexOf(conn); + Debug.assert(idx !== -1); + list.splice(idx, 1); + if(list.length === 0) + { + this.delete(key); + } + }, + map: function(fn) + { + var arr = []; + this.forEach(function(c) { arr.push(fn(c)); }); + return arr; + }, + forEach: function(fn) + { + for(var e = this._head; e !== null; e = e._next) + { + for(var i = 0; i < e.value.length; ++i) + { + fn(e.value[i]); + } + } + } + }); + + var ConnectCallback = Class({ + __init__: function(f, endpoints, more, selType) + { + this._factory = f; + this._endpoints = endpoints; + this._hasMore = more; + this._selType = selType; + this._promise = new Promise(); + this._index = 0; + this._current = null; + }, + // + // Methods from ConnectionI_StartCallback + // + connectionStartCompleted: function(connection) + { + connection.activate(); + this._factory.finishGetConnection(this._endpoints, this._current, connection, this); + }, + connectionStartFailed: function(connection, ex) + { + Debug.assert(this._current !== null); + + if(ex instanceof Ice.LocalException) + { + this._factory.handleConnectionException(ex, this._hasMore || this._index < this._endpoints.length); + if(ex instanceof Ice.CommunicatorDestroyedException) // No need to continue. + { + this._factory.finishGetConnectionEx(this._endpoints, ex, this); + } + else if(this._index < this._endpoints.length) // Try the next endpoint. + { + this.nextEndpoint(); + } + else + { + this._factory.finishGetConnectionEx(this._endpoints, ex, this); + } + } + else + { + this._factory.finishGetConnectionEx(this._endpoints, ex, this); + } + }, + setConnection: function(connection, compress) + { + // + // Callback from the factory: the connection to one of the callback + // connectors has been established. + // + this._promise.succeed(connection, compress); + this._factory.decPendingConnectCount(); // Must be called last. + }, + setException: function(ex) + { + // + // Callback from the factory: connection establishment failed. + // + this._promise.fail(ex); + this._factory.decPendingConnectCount(); // Must be called last. + }, + hasEndpoint: function(endpt) + { + return this.findEndpoint(endpt) !== -1; + }, + findEndpoint: function(endpt) + { + for(var index = 0; index < this._endpoints.length; ++index) + { + if(endpt.equals(this._endpoints[index])) + { + return index; + } + } + return -1; + }, + removeEndpoints: function(endpoints) + { + for(var i = 0; i < endpoints.length; ++i) + { + var idx = this.findEndpoint(endpoints[i]); + if(idx !== -1) + { + this._endpoints.splice(idx, 1); + } + } + this._index = 0; + return this._endpoints.length === 0; + }, + removeFromPending: function() + { + this._factory.removeFromPending(this, this._endpoints); + }, + start: function() + { + try + { + // + // Notify the factory that there's an async connect pending. This is necessary + // to prevent the outgoing connection factory to be destroyed before all the + // pending asynchronous connects are finished. + // + this._factory.incPendingConnectCount(); + } + catch(ex) + { + this._promise.fail(ex); + return; + } + + this.getConnection(); + return this._promise; + }, + getConnection: function() + { + try + { + // + // Ask the factory to get a connection. + // + var compress = { value: false }; + var connection = this._factory.getConnection(this._endpoints, this, compress); + if(connection === null) + { + // + // A null return value from getConnection indicates that the connection + // is being established and that everthing has been done to ensure that + // the callback will be notified when the connection establishment is + // done. + // + return; + } + + this._promise.succeed(connection, compress.value); + this._factory.decPendingConnectCount(); // Must be called last. + } + catch(ex) + { + this._promise.fail(ex); + this._factory.decPendingConnectCount(); // Must be called last. + } + }, + nextEndpoint: function() + { + var connection = null; + try + { + Debug.assert(this._index < this._endpoints.length); + this._current = this._endpoints[this._index++]; + connection = this._factory.createConnection(this._current.connect(), this._current); + var self = this; + connection.start().then( + function() + { + self.connectionStartCompleted(connection); + }, + function(ex) + { + self.connectionStartFailed(connection, ex); + }); + } + catch(ex) + { + this.connectionStartFailed(connection, ex); + } + } + }); + +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ProcessLogger.js b/js/src/Ice/ProcessLogger.js new file mode 100644 index 00000000000..b414d183adc --- /dev/null +++ b/js/src/Ice/ProcessLogger.js @@ -0,0 +1,39 @@ + +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Logger"); + var Ice = global.Ice || {}; + var Logger = Ice.Logger; + + var processLogger = null; + + var getProcessLogger = function() + { + if(processLogger === null) + { + // + // TODO: Would be nice to be able to use process name as prefix by default. + // + processLogger = new Logger("", ""); + } + + return processLogger; + }; + + var setProcessLogger = function(logger) + { + processLogger = logger; + }; + + Ice.getProcessLogger = getProcessLogger; + Ice.setProcessLogger = setProcessLogger; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Promise.js b/js/src/Ice/Promise.js new file mode 100644 index 00000000000..91608d13873 --- /dev/null +++ b/js/src/Ice/Promise.js @@ -0,0 +1,297 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + + var Ice = global.Ice || {}; + + // + // Promise State + // + var State = {Pending: 0, Success: 1, Failed: 2}; + + var resolveImp = function(self, listener) + { + var callback = self.__state === State.Success ? listener.onResponse : listener.onException; + try + { + if(typeof callback !== "function") + { + listener.promise.setState(self.__state, self._args); + } + else + { + var result = callback.apply(null, self._args); + + // + // Callback can return a new promise. + // + if(result && typeof result.then == "function") + { + result.then( + function() + { + var args = arguments; + listener.promise.succeed.apply(listener.promise, args); + }, + function() + { + var args = arguments; + listener.promise.fail.apply(listener.promise, args); + }); + } + else + { + listener.promise.succeed(result); + } + } + } + catch(e) + { + listener.promise.fail.call(listener.promise, e); + } + }; + + var Promise = Ice.Class({ + __init__: function() + { + this.__state = State.Pending; + this.__listeners = []; + }, + then: function(onResponse, onException) + { + var promise = new Promise(); + var self = this; + // + // Use setTimeout so the listeners are not resolved until the call stack is empty. + // + setTimeout( + function() + { + self.__listeners.push( + { + promise:promise, + onResponse:onResponse, + onException:onException + }); + self.resolve(); + }, 0); + return promise; + }, + exception: function(onException) + { + return this.then(null, onException); + }, + finally: function(cb) + { + var p = new Promise(); + var self = this; + + var finallyHandler = function(method) + { + return function() + { + var args = arguments; + try + { + var result = cb.apply(null, args); + if(result && typeof result.then == "function") + { + var handler = function(){ method.apply(p, args); }; + result.then(handler).exception(handler); + } + else + { + method.apply(p, args); + } + } + catch(e) + { + method.apply(p, args); + } + }; + }; + + setTimeout( + function(){ + self.then(finallyHandler(p.succeed), finallyHandler(p.fail)); + }); + return p; + }, + delay: function(ms) + { + var p = new Promise(); + + var self = this; + + var delayHandler = function(promise, method) + { + return function() + { + var args = arguments; + setTimeout( + function() + { + method.apply(promise, args); + }, + ms); + }; + }; + + setTimeout( + function() + { + self.then(delayHandler(p, p.succeed), + delayHandler(p, p.fail)); + }); + + return p; + }, + resolve: function() + { + if(this.__state === State.Pending) + { + return; + } + + var obj; + while((obj = this.__listeners.pop())) + { + // + // We use a separate function here to capture the listeners + // in the loop. + // + resolveImp(this, obj); + } + }, + setState: function(state, args) + { + if(this.__state === State.Pending && state !== State.Pending) + { + this.__state = state; + this._args = args; + // + // Use setTimeout so the listeners are not resolved until the call stack is empty. + // + var self = this; + setTimeout(function(){ self.resolve(); }, 0); + } + }, + succeed: function() + { + var args = arguments; + this.setState(State.Success, args); + return this; + }, + fail: function() + { + var args = arguments; + this.setState(State.Failed, args); + return this; + }, + succeeded: function() + { + return this.__state === State.Success; + }, + failed: function() + { + return this.__state === State.Failed; + }, + completed: function() + { + return this.__state !== State.Pending; + } + }); + + // + // Create a new promise object that is fulfilled when all the promise arguments + // are fulfilled or is rejected when one of the promises is rejected. + // + Promise.all = function() + { + // If only one argument is provided, check if the argument is an array + if(arguments.length === 1 && arguments[0] instanceof Array) + { + return Promise.all.apply(this, arguments[0]); + } + + var promise = new Promise(); + var promises = Array.prototype.slice.call(arguments); + var results = new Array(arguments.length); + + var pending = promises.length; + if(pending === 0) + { + promise.succeed.apply(promise, results); + } + for(var i = 0; i < promises.length; ++i) + { + // + // Create an anonymous function to capture the loop index + // + + /*jshint -W083 */ + (function(j) + { + if(promises[j] && typeof promises[j].then == "function") + { + promises[j].then( + function() + { + results[j] = arguments; + pending--; + if(pending === 0) + { + promise.succeed.apply(promise, results); + } + }, + function() + { + promise.fail.apply(promise, arguments); + }); + } + else + { + results[j] = promises[j]; + pending--; + if(pending === 0) + { + promise.succeed.apply(promise, results); + } + } + }(i)); + /*jshint +W083 */ + } + return promise; + }; + + Promise.try = function(onResponse) + { + return new Promise().succeed().then(onResponse); + }; + + Promise.delay = function(ms) + { + if(arguments.length > 1) + { + var p = new Promise(); + var args = Array.prototype.slice.call(arguments); + ms = args.pop(); + return p.succeed.apply(p, args).delay(ms); + } + else + { + return new Promise().succeed().delay(ms); + } + }; + + Ice.Promise = Promise; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Properties.js b/js/src/Ice/Properties.js new file mode 100644 index 00000000000..3f63204a7fa --- /dev/null +++ b/js/src/Ice/Properties.js @@ -0,0 +1,504 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/StringUtil"); + require("Ice/HashMap"); + require("Ice/Promise"); + require("Ice/PropertyNames"); + require("Ice/Debug"); + require("Ice/ProcessLogger"); + require("Ice/ProcessLogger"); + require("Ice/LocalException"); + + var Ice = global.Ice || {}; + + var StringUtil = Ice.StringUtil; + var HashMap = Ice.HashMap; + var Promise = Ice.Promise; + var PropertyNames = Ice.PropertyNames; + var Debug = Ice.Debug; + var ProcessLogger = Ice.ProcessLogger; + var getProcessLogger = Ice.getProcessLogger; + var InitializationException = Ice.InitializationException; + + var ParseStateKey = 0; + var ParseStateValue = 1; + // + // Ice.Properties + // + var Properties = Ice.Class({ + __init__: function(args, defaults) + { + this._properties = new HashMap(); + + if(defaults !== undefined && defaults !== null) + { + // + // NOTE: we can't just do a shallow copy of the map as the map values + // would otherwise be shared between the two PropertiesI object. + // + //_properties = new HashMap(pi._properties); + for(var e = defaults._properties.entries; e !== null; e = e.next) + { + this._properties.set(e.key, { 'value': e.value.value, 'used': false }); + } + } + + if(args !== undefined && args !== null) + { + var v = this.parseIceCommandLineOptions(args); + args.length = 0; + for(var i = 0; i < v.length; ++i) + { + args.push(v[i]); + } + } + }, + getProperty: function(key) + { + return this.getPropertyWithDefault(key, ""); + }, + getPropertyWithDefault: function(key, value) + { + var pv = this._properties.get(key); + if(pv !== undefined) + { + pv.used = true; + return pv.value; + } + else + { + return value; + } + }, + getPropertyAsInt: function(key) + { + return this.getPropertyAsIntWithDefault(key, 0); + }, + getPropertyAsIntWithDefault: function(key, value) + { + var pv = this._properties.get(key); + if(pv !== undefined) + { + pv.used = true; + return parseInt(pv.value); + } + else + { + return value; + } + }, + getPropertyAsList: function(key) + { + return this.getPropertyAsListWithDefault(key, 0); + }, + getPropertyAsListWithDefault: function(key, value) + { + if(value === undefined || value === null) + { + value = []; + } + + var pv = this._properties.get(key); + if(pv !== undefined) + { + pv.used = true; + + var result = StringUtil.splitString(pv.value, ", \t\r\n"); + if(result === null) + { + getProcessLogger().warning("mismatched quotes in property " + key + "'s value, returning default value"); + return value; + } + if(result.length === 0) + { + result = value; + } + return result; + } + else + { + return value; + } + }, + getPropertiesForPrefix: function(prefix) + { + var result = new HashMap(); + for(var e = this._properties.entries; e !== null; e = e.next) + { + if(prefix === undefined || prefix === null || e.key.indexOf(prefix) === 0) + { + e.value.used = true; + result.set(e.key, e.value.value); + } + } + return result; + }, + setProperty: function(key, value) + { + // + // Trim whitespace + // + if(key !== null && key !== undefined) + { + key = key.trim(); + } + + // + // Check if the property is legal. + // + var logger = getProcessLogger(); + if(key === null || key === undefined || key.length === 0) + { + throw new InitializationException("Attempt to set property with empty key"); + } + + var dotPos = key.indexOf("."); + if(dotPos !== -1) + { + var prefix = key.substr(0, dotPos); + for(var i = 0; i < PropertyNames.validProps.length; ++i) + { + var pattern = PropertyNames.validProps[i][0].pattern; + dotPos = pattern.indexOf("."); + // + // Each top level prefix describes a non-empty namespace. Having a string without a + // prefix followed by a dot is an error. + // + Debug.assert(dotPos != -1); + var propPrefix = pattern.substring(0, dotPos - 1); + if(propPrefix != prefix) + { + continue; + } + + var found = false; + var mismatchCase = false; + var otherKey; + for(var j = 0; j < PropertyNames.validProps[i][j].length && !found; ++j) + { + pattern = PropertyNames.validProps[i][j].pattern(); + var pComp = new RegExp(pattern); + found = pComp.test(key); + + if(found && PropertyNames.validProps[i][j].deprecated) + { + logger.warning("deprecated property: " + key); + if(PropertyNames.validProps[i][j].deprecatedBy !== null) + { + key = PropertyNames.validProps[i][j].deprecatedBy; + } + } + + if(found) + { + break; + } + else + { + pComp = new RegExp(pattern.toUpperCase()); + found = pComp.test(key.toUpperCase()); + if(found) + { + mismatchCase = true; + otherKey = pattern.substr(2); + otherKey = otherKey.substr(0, otherKey.length -1); + otherKey = otherKey.replace(/\\/g, ""); + break; + } + } + } + + if(!found) + { + logger.warning("unknown property: " + key); + } + else if(mismatchCase) + { + logger.warning("unknown property: `" + key + "'; did you mean `" + otherKey + "'"); + } + } + } + + // + // Set or clear the property. + // + if(value !== undefined && value !== null && value.length > 0) + { + var pv = this._properties.get(key); + if(pv !== undefined) + { + pv.value = value; + } + else + { + this._properties.set(key, { 'value': value, 'used': false }); + } + } + else + { + this._properties.delete(key); + } + }, + getCommandLineOptions: function() + { + var result = []; + for(var e = this._properties.entries; e !== null; e = e.next) + { + result.push("--" + e.key + "=" + e.pv.value); + } + return result; + }, + parseCommandLineOptions: function(pfx, options) + { + if(pfx.length > 0 && pfx.charAt(pfx.length - 1) != ".") + { + pfx += "."; + } + pfx = "--" + pfx; + + var result = []; + + var self = this; + options.forEach( + function(opt) + { + if(opt.indexOf(pfx) === 0) + { + if(opt.indexOf('=') === -1) + { + opt += "=1"; + } + + self.parseLine(opt.substring(2)); + } + else + { + result.push(opt); + } + }); + return result; + }, + parseIceCommandLineOptions: function(options) + { + var args = options.slice(); + for(var i = 0; i < PropertyNames.clPropNames.length; ++i) + { + args = this.parseCommandLineOptions(PropertyNames.clPropNames[i], args); + } + return args; + }, + parse: function(data) + { + var lines = data.match(/[^\r\n]+/g); + + var line; + + while((line = lines.shift())) + { + this.parseLine(line); + } + }, + parseLine: function(line) + { + var key = ""; + var value = ""; + + var state = ParseStateKey; + + var whitespace = ""; + var escapedspace = ""; + var finished = false; + + for(var i = 0; i < line.length; ++i) + { + var c = line.charAt(i); + switch(state) + { + case ParseStateKey: + { + switch(c) + { + case '\\': + if(i < line.length - 1) + { + c = line.charAt(++i); + switch(c) + { + case '\\': + case '#': + case '=': + key += whitespace; + whitespace = ""; + key += c; + break; + + case ' ': + if(key.length !== 0) + { + whitespace += c; + } + break; + + default: + key += whitespace; + whitespace = ""; + key += '\\'; + key += c; + break; + } + } + else + { + key += whitespace; + key += c; + } + break; + + case ' ': + case '\t': + case '\r': + case '\n': + if(key.length !== 0) + { + whitespace += c; + } + break; + + case '=': + whitespace = ""; + state = ParseStateValue; + break; + + case '#': + finished = true; + break; + + default: + key += whitespace; + whitespace = ""; + key += c; + break; + } + break; + } + + case ParseStateValue: + { + switch(c) + { + case '\\': + if(i < line.length - 1) + { + c = line.charAt(++i); + switch(c) + { + case '\\': + case '#': + case '=': + value += value.length === 0 ? escapedspace : whitespace; + whitespace = ""; + escapedspace = ""; + value += c; + break; + + case ' ': + whitespace += c; + escapedspace += c; + break; + + default: + value += value.length === 0 ? escapedspace : whitespace; + whitespace = ""; + escapedspace = ""; + value += '\\'; + value += c; + break; + } + } + else + { + value += value.length === 0 ? escapedspace : whitespace; + value += c; + } + break; + + case ' ': + case '\t': + case '\r': + case '\n': + if(value.length !== 0) + { + whitespace += c; + } + break; + + case '#': + value += escapedspace; + finished = true; + break; + + default: + value += value.length === 0 ? escapedspace : whitespace; + whitespace = ""; + escapedspace = ""; + value += c; + break; + } + break; + } + } + if(finished) + { + break; + } + } + value += escapedspace; + + if((state === ParseStateKey && key.length !== 0) || + (state == ParseStateValue && key.length === 0)) + { + getProcessLogger().warning("invalid config file entry: \"" + line + "\""); + return; + } + else if(key.length === 0) + { + return; + } + + this.setProperty(key, value); + }, + clone: function() + { + return new Properties(null, this); + }, + getUnusedProperties: function() + { + var unused = []; + for(var e = this._properties.entries; e !== null; e = e.next) + { + if(!e.pv.used) + { + unused.push(e.key); + } + } + return unused; + } + }); + + Properties.createProperties = function(args, defaults) + { + return new Properties(args, defaults); + }; + + Ice.Properties = Properties; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Property.js b/js/src/Ice/Property.js new file mode 100644 index 00000000000..3bea3d09caf --- /dev/null +++ b/js/src/Ice/Property.js @@ -0,0 +1,34 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + var Ice = global.Ice || {}; + + var Property = function Property(pattern, deprecated, deprecatedBy) + { + this._pattern = pattern; + this._deprecated = deprecated; + this._deprecatedBy = deprecatedBy; + }; + + Object.defineProperty(Property.prototype, "pattern",{ + get: function() { return this._pattern; } + }); + + Object.defineProperty(Property.prototype, "deprecated",{ + get: function() { return this._deprecated; } + }); + + Object.defineProperty(Property.prototype, "deprecatedBy",{ + get: function() { return this._deprecatedBy; } + }); + + Ice.Property = Property; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/PropertyNames.js b/js/src/Ice/PropertyNames.js new file mode 100644 index 00000000000..5537b8c9d14 --- /dev/null +++ b/js/src/Ice/PropertyNames.js @@ -0,0 +1,177 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +///* jshint -W044*/ +// Generated by makeprops.py from file PropertyNames.xml, Tue Feb 4 16:00:18 2014 + +// IMPORTANT: Do not edit this file -- any edits made here will be lost! + +(function(global){ + var Ice = global.Ice || Ice; + require("Ice/Property"); + var PropertyNames = {}; + var Property = Ice.Property; + /* jshint -W044*/ + + PropertyNames.IceProps = + [ + new Property("/^Ice\.ACM\.Client/", false, null), + new Property("/^Ice\.ACM\.Server/", false, null), + new Property("/^Ice\.Admin\.ACM/", false, null), + new Property("/^Ice\.Admin\.AdapterId/", false, null), + new Property("/^Ice\.Admin\.Endpoints/", false, null), + new Property("/^Ice\.Admin\.Locator\.EndpointSelection/", false, null), + new Property("/^Ice\.Admin\.Locator\.ConnectionCached/", false, null), + new Property("/^Ice\.Admin\.Locator\.PreferSecure/", false, null), + new Property("/^Ice\.Admin\.Locator\.LocatorCacheTimeout/", false, null), + new Property("/^Ice\.Admin\.Locator\.Locator/", false, null), + new Property("/^Ice\.Admin\.Locator\.Router/", false, null), + new Property("/^Ice\.Admin\.Locator\.CollocationOptimized/", false, null), + new Property("/^Ice\.Admin\.Locator/", false, null), + new Property("/^Ice\.Admin\.PublishedEndpoints/", false, null), + new Property("/^Ice\.Admin\.ReplicaGroupId/", false, null), + new Property("/^Ice\.Admin\.Router\.EndpointSelection/", false, null), + new Property("/^Ice\.Admin\.Router\.ConnectionCached/", false, null), + new Property("/^Ice\.Admin\.Router\.PreferSecure/", false, null), + new Property("/^Ice\.Admin\.Router\.LocatorCacheTimeout/", false, null), + new Property("/^Ice\.Admin\.Router\.Locator/", false, null), + new Property("/^Ice\.Admin\.Router\.Router/", false, null), + new Property("/^Ice\.Admin\.Router\.CollocationOptimized/", false, null), + new Property("/^Ice\.Admin\.Router/", false, null), + new Property("/^Ice\.Admin\.ProxyOptions/", false, null), + new Property("/^Ice\.Admin\.ThreadPool\.Size/", false, null), + new Property("/^Ice\.Admin\.ThreadPool\.SizeMax/", false, null), + new Property("/^Ice\.Admin\.ThreadPool\.SizeWarn/", false, null), + new Property("/^Ice\.Admin\.ThreadPool\.StackSize/", false, null), + new Property("/^Ice\.Admin\.ThreadPool\.Serialize/", false, null), + new Property("/^Ice\.Admin\.ThreadPool\.ThreadIdleTime/", false, null), + new Property("/^Ice\.Admin\.ThreadPool\.ThreadPriority/", false, null), + new Property("/^Ice\.Admin\.DelayCreation/", false, null), + new Property("/^Ice\.Admin\.Facets/", false, null), + new Property("/^Ice\.Admin\.InstanceName/", false, null), + new Property("/^Ice\.Admin\.ServerId/", false, null), + new Property("/^Ice\.BackgroundLocatorCacheUpdates/", false, null), + new Property("/^Ice\.BatchAutoFlush/", false, null), + new Property("/^Ice\.ChangeUser/", false, null), + new Property("/^Ice\.ClientAccessPolicyProtocol/", false, null), + new Property("/^Ice\.Compression\.Level/", false, null), + new Property("/^Ice\.Config/", false, null), + new Property("/^Ice\.ConsoleListener/", false, null), + new Property("/^Ice\.Default\.CollocationOptimized/", false, null), + new Property("/^Ice\.Default\.EncodingVersion/", false, null), + new Property("/^Ice\.Default\.EndpointSelection/", false, null), + new Property("/^Ice\.Default\.Host/", false, null), + new Property("/^Ice\.Default\.Locator\.EndpointSelection/", false, null), + new Property("/^Ice\.Default\.Locator\.ConnectionCached/", false, null), + new Property("/^Ice\.Default\.Locator\.PreferSecure/", false, null), + new Property("/^Ice\.Default\.Locator\.LocatorCacheTimeout/", false, null), + new Property("/^Ice\.Default\.Locator\.Locator/", false, null), + new Property("/^Ice\.Default\.Locator\.Router/", false, null), + new Property("/^Ice\.Default\.Locator\.CollocationOptimized/", false, null), + new Property("/^Ice\.Default\.Locator/", false, null), + new Property("/^Ice\.Default\.LocatorCacheTimeout/", false, null), + new Property("/^Ice\.Default\.Package/", false, null), + new Property("/^Ice\.Default\.PreferSecure/", false, null), + new Property("/^Ice\.Default\.Protocol/", false, null), + new Property("/^Ice\.Default\.Router\.EndpointSelection/", false, null), + new Property("/^Ice\.Default\.Router\.ConnectionCached/", false, null), + new Property("/^Ice\.Default\.Router\.PreferSecure/", false, null), + new Property("/^Ice\.Default\.Router\.LocatorCacheTimeout/", false, null), + new Property("/^Ice\.Default\.Router\.Locator/", false, null), + new Property("/^Ice\.Default\.Router\.Router/", false, null), + new Property("/^Ice\.Default\.Router\.CollocationOptimized/", false, null), + new Property("/^Ice\.Default\.Router/", false, null), + new Property("/^Ice\.Default\.SlicedFormat/", false, null), + new Property("/^Ice\.IPv4/", false, null), + new Property("/^Ice\.IPv6/", false, null), + new Property("/^Ice\.EventLog\.Source/", false, null), + new Property("/^Ice\.FactoryAssemblies/", false, null), + new Property("/^Ice\.GC\.Interval/", false, null), + new Property("/^Ice\.ImplicitContext/", false, null), + new Property("/^Ice\.InitPlugins/", false, null), + new Property("/^Ice\.LogFile/", false, null), + new Property("/^Ice\.MessageSizeMax/", false, null), + new Property("/^Ice\.MonitorConnections/", false, null), + new Property("/^Ice\.Nohup/", false, null), + new Property("/^Ice\.NullHandleAbort/", false, null), + new Property("/^Ice\.Override\.CloseTimeout/", false, null), + new Property("/^Ice\.Override\.Compress/", false, null), + new Property("/^Ice\.Override\.ConnectTimeout/", false, null), + new Property("/^Ice\.Override\.Timeout/", false, null), + new Property("/^Ice\.Override\.Secure/", false, null), + new Property("/^Ice\.Package\../", false, null), + new Property("/^Ice\.Plugin\../", false, null), + new Property("/^Ice\.PluginLoadOrder/", false, null), + new Property("/^Ice\.PreferIPv6Address/", false, null), + new Property("/^Ice\.PrintAdapterReady/", false, null), + new Property("/^Ice\.PrintProcessId/", false, null), + new Property("/^Ice\.PrintStackTraces/", false, null), + new Property("/^Ice\.ProgramName/", false, null), + new Property("/^Ice\.RetryIntervals/", false, null), + new Property("/^Ice\.ServerIdleTime/", false, null), + new Property("/^Ice\.SOCKSProxyHost/", false, null), + new Property("/^Ice\.SOCKSProxyPort/", false, null), + new Property("/^Ice\.StdErr/", false, null), + new Property("/^Ice\.StdOut/", false, null), + new Property("/^Ice\.SyslogFacility/", false, null), + new Property("/^Ice\.ThreadPool\.Client\.Size/", false, null), + new Property("/^Ice\.ThreadPool\.Client\.SizeMax/", false, null), + new Property("/^Ice\.ThreadPool\.Client\.SizeWarn/", false, null), + new Property("/^Ice\.ThreadPool\.Client\.StackSize/", false, null), + new Property("/^Ice\.ThreadPool\.Client\.Serialize/", false, null), + new Property("/^Ice\.ThreadPool\.Client\.ThreadIdleTime/", false, null), + new Property("/^Ice\.ThreadPool\.Client\.ThreadPriority/", false, null), + new Property("/^Ice\.ThreadPool\.Server\.Size/", false, null), + new Property("/^Ice\.ThreadPool\.Server\.SizeMax/", false, null), + new Property("/^Ice\.ThreadPool\.Server\.SizeWarn/", false, null), + new Property("/^Ice\.ThreadPool\.Server\.StackSize/", false, null), + new Property("/^Ice\.ThreadPool\.Server\.Serialize/", false, null), + new Property("/^Ice\.ThreadPool\.Server\.ThreadIdleTime/", false, null), + new Property("/^Ice\.ThreadPool\.Server\.ThreadPriority/", false, null), + new Property("/^Ice\.ThreadPriority/", false, null), + new Property("/^Ice\.Trace\.Admin\.Properties/", false, null), + new Property("/^Ice\.Trace\.GC/", false, null), + new Property("/^Ice\.Trace\.Locator/", false, null), + new Property("/^Ice\.Trace\.Network/", false, null), + new Property("/^Ice\.Trace\.Protocol/", false, null), + new Property("/^Ice\.Trace\.Retry/", false, null), + new Property("/^Ice\.Trace\.Slicing/", false, null), + new Property("/^Ice\.Trace\.ThreadPool/", false, null), + new Property("/^Ice\.UDP\.RcvSize/", false, null), + new Property("/^Ice\.UDP\.SndSize/", false, null), + new Property("/^Ice\.TCP\.Backlog/", false, null), + new Property("/^Ice\.TCP\.RcvSize/", false, null), + new Property("/^Ice\.TCP\.SndSize/", false, null), + new Property("/^Ice\.UseApplicationClassLoader/", false, null), + new Property("/^Ice\.UseSyslog/", false, null), + new Property("/^Ice\.Warn\.AMICallback/", false, null), + new Property("/^Ice\.Warn\.Connections/", false, null), + new Property("/^Ice\.Warn\.Datagrams/", false, null), + new Property("/^Ice\.Warn\.Dispatch/", false, null), + new Property("/^Ice\.Warn\.Endpoints/", false, null), + new Property("/^Ice\.Warn\.UnknownProperties/", false, null), + new Property("/^Ice\.Warn\.UnusedProperties/", false, null), + new Property("/^Ice\.CacheMessageBuffers/", false, null), + ]; + + /* jshint +W044*/ + + PropertyNames.validProps = + [ + PropertyNames.IceProps, + ]; + + PropertyNames.clPropNames = + [ + "Ice", + ]; + + Ice.PropertyNames = PropertyNames; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Protocol.js b/js/src/Ice/Protocol.js new file mode 100644 index 00000000000..12d71fdcdae --- /dev/null +++ b/js/src/Ice/Protocol.js @@ -0,0 +1,316 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/StringUtil"); + require("Ice/LocalException"); + require("Ice/Version"); + require("Ice/Buffer"); + + var Ice = global.Ice || {}; + + var StringUtil = Ice.StringUtil; + + var Protocol = {}; + + Ice.Encoding_1_0 = new Ice.EncodingVersion(1, 0); + Ice.Encoding_1_1 = new Ice.EncodingVersion(1, 1); + + Ice.Protocol_1_0 = new Ice.ProtocolVersion(1, 0); + + // + // Size of the Ice protocol header + // + // Magic number (4 bytes) + // Protocol version major (Byte) + // Protocol version minor (Byte) + // Encoding version major (Byte) + // Encoding version minor (Byte) + // Message type (Byte) + // Compression status (Byte) + // Message size (Int) + // + Protocol.headerSize = 14; + + // + // The magic number at the front of each message + // + //Protocol.magic = [ 0x49, 0x63, 0x65, 0x50 ]; // 'I', 'c', 'e', 'P' + Protocol.magic = Ice.Buffer.createNative([ 0x49, 0x63, 0x65, 0x50 ]); // 'I', 'c', 'e', 'P' + + // + // The current Ice protocol and encoding version + // + Protocol.protocolMajor = 1; + Protocol.protocolMinor = 0; + Protocol.protocolEncodingMajor = 1; + Protocol.protocolEncodingMinor = 0; + + Protocol.encodingMajor = 1; + Protocol.encodingMinor = 1; + + // + // The Ice protocol message types + // + Protocol.requestMsg = 0; + Protocol.requestBatchMsg = 1; + Protocol.replyMsg = 2; + Protocol.validateConnectionMsg = 3; + Protocol.closeConnectionMsg = 4; + + // + // Reply status + // + Protocol.replyOK = 0; + Protocol.replyUserException = 1; + Protocol.replyObjectNotExist = 2; + Protocol.replyFacetNotExist = 3; + Protocol.replyOperationNotExist = 4; + Protocol.replyUnknownLocalException = 5; + Protocol.replyUnknownUserException = 6; + Protocol.replyUnknownException = 7; + + Protocol.requestHdr = Ice.Buffer.createNative([ + Protocol.magic[0], + Protocol.magic[1], + Protocol.magic[2], + Protocol.magic[3], + Protocol.protocolMajor, + Protocol.protocolMinor, + Protocol.protocolEncodingMajor, + Protocol.protocolEncodingMinor, + Protocol.requestMsg, + 0, // Compression status. + 0, 0, 0, 0, // Message size (placeholder). + 0, 0, 0, 0 // Request ID (placeholder). + ]); + + Protocol.requestBatchHdr = Ice.Buffer.createNative([ + Protocol.magic[0], + Protocol.magic[1], + Protocol.magic[2], + Protocol.magic[3], + Protocol.protocolMajor, + Protocol.protocolMinor, + Protocol.protocolEncodingMajor, + Protocol.protocolEncodingMinor, + Protocol.requestBatchMsg, + 0, // Compression status. + 0, 0, 0, 0, // Message size (placeholder). + 0, 0, 0, 0 // Number of requests in batch (placeholder). + ]); + + Protocol.replyHdr = Ice.Buffer.createNative([ + Protocol.magic[0], + Protocol.magic[1], + Protocol.magic[2], + Protocol.magic[3], + Protocol.protocolMajor, + Protocol.protocolMinor, + Protocol.protocolEncodingMajor, + Protocol.protocolEncodingMinor, + Protocol.replyMsg, + 0, // Compression status. + 0, 0, 0, 0 // Message size (placeholder). + ]); + + Protocol.currentProtocol = new Ice.ProtocolVersion(Protocol.protocolMajor, Protocol.protocolMinor); + Protocol.currentProtocolEncoding = new Ice.EncodingVersion(Protocol.protocolEncodingMajor, + Protocol.protocolEncodingMinor); + + Protocol.currentEncoding = new Ice.EncodingVersion(Protocol.encodingMajor, Protocol.encodingMinor); + + Protocol.checkSupportedProtocol = function(v) + { + if(v.major !== Protocol.currentProtocol.major || v.minor > Protocol.currentProtocol.minor) + { + throw new Ice.UnsupportedProtocolException("", v, Protocol.currentProtocol); + } + }; + + Protocol.checkSupportedProtocolEncoding = function(v) + { + if(v.major !== Protocol.currentProtocolEncoding.major || + v.minor > Protocol.currentProtocolEncoding.minor) + { + throw new Ice.UnsupportedEncodingException("", v, Protocol.currentProtocolEncoding); + } + }; + + Protocol.checkSupportedEncoding = function(v) + { + if(v.major !== Protocol.currentEncoding.major || v.minor > Protocol.currentEncoding.minor) + { + throw new Ice.UnsupportedEncodingException("", v, Protocol.currentEncoding); + } + }; + + // + // Either return the given protocol if not compatible, or the greatest + // supported protocol otherwise. + // + Protocol.getCompatibleProtocol = function(v) + { + if(v.major !== Protocol.currentProtocol.major) + { + return v; // Unsupported protocol, return as is. + } + else if(v.minor < Protocol.currentProtocol.minor) + { + return v; // Supported protocol. + } + else + { + // + // Unsupported but compatible, use the currently supported + // protocol, that's the best we can do. + // + return Protocol.currentProtocol; + } + }; + + // + // Either return the given encoding if not compatible, or the greatest + // supported encoding otherwise. + // + Protocol.getCompatibleEncoding = function(v) + { + if(v.major !== Protocol.currentEncoding.major) + { + return v; // Unsupported encoding, return as is. + } + else if(v.minor < Protocol.currentEncoding.minor) + { + return v; // Supported encoding. + } + else + { + // + // Unsupported but compatible, use the currently supported + // encoding, that's the best we can do. + // + return Protocol.currentEncoding; + } + }; + + Protocol.isSupported = function(version, supported) + { + return version.major === supported.major && version.minor <= supported.minor; + }; + + /** + * Converts a string to a protocol version. + * + * @param version The string to convert. + * + * @return The converted protocol version. + **/ + Ice.stringToProtocolVersion = function(version) + { + return new Ice.ProtocolVersion(stringToMajor(version), stringToMinor(version)); + }; + + /** + * Converts a string to an encoding version. + * + * @param version The string to convert. + * + * @return The converted object identity. + **/ + Ice.stringToEncodingVersion = function(version) + { + return new Ice.EncodingVersion(stringToMajor(version), stringToMinor(version)); + }; + + /** + * Converts a protocol version to a string. + * + * @param v The protocol version to convert. + * + * @return The converted string. + **/ + Ice.protocolVersionToString = function(v) + { + return majorMinorToString(v.major, v.minor); + }; + + /** + * Converts an encoding version to a string. + * + * @param v The encoding version to convert. + * + * @return The converted string. + **/ + Ice.encodingVersionToString = function(v) + { + return majorMinorToString(v.major, v.minor); + }; + + Ice.Protocol = Protocol; + global.Ice = Ice; + + function stringToMajor(str) + { + var pos = str.indexOf('.'); + if(pos === -1) + { + throw new Ice.VersionParseException("malformed version value `" + str + "'"); + } + + var majStr = str.substring(0, pos); + var majVersion; + try + { + majVersion = StringUtil.toInt(majStr); + } + catch(ex) + { + throw new Ice.VersionParseException("invalid version value `" + str + "'"); + } + + if(majVersion < 1 || majVersion > 255) + { + throw new Ice.VersionParseException("range error in version `" + str + "'"); + } + + return majVersion; + } + + function stringToMinor(str) + { + var pos = str.indexOf('.'); + if(pos === -1) + { + throw new Ice.VersionParseException("malformed version value `" + str + "'"); + } + + var minStr = str.substring(pos + 1); + var minVersion; + try + { + minVersion = StringUtil.toInt(minStr); + } + catch(ex) + { + throw new Ice.VersionParseException("invalid version value `" + str + "'"); + } + + if(minVersion < 0 || minVersion > 255) + { + throw new Ice.VersionParseException("range error in version `" + str + "'"); + } + + return minVersion; + } + + function majorMinorToString(major, minor) + { + return major + "." + minor; + } +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ProxyBatchOutgoingAsync.js b/js/src/Ice/ProxyBatchOutgoingAsync.js new file mode 100644 index 00000000000..372ee9dcc3e --- /dev/null +++ b/js/src/Ice/ProxyBatchOutgoingAsync.js @@ -0,0 +1,54 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_FOR_ACTIONSCRIPT_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/AsyncResult"); + require("Ice/AsyncStatus"); + require("Ice/BatchOutgoingAsync"); + require("Ice/Protocol"); + + var Ice = global.Ice || {}; + + var AsyncResult = Ice.AsyncResult; + var AsyncStatus = Ice.AsyncStatus; + var BatchOutgoingAsync = Ice.BatchOutgoingAsync; + var Protocol = Ice.Protocol; + + var ProxyBatchOutgoingAsync = Ice.Class(BatchOutgoingAsync, { + __init__: function(prx, operation) + { + BatchOutgoingAsync.call(this, prx.ice_getCommunicator(), operation); + this._proxy = prx; + }, + __send: function() + { + Protocol.checkSupportedProtocol(this._proxy.__reference().getProtocol()); + + // + // We don't automatically retry if ice_flushBatchRequests fails. Otherwise, if some batch + // requests were queued with the connection, they would be lost without being noticed. + // + var handler = null; + var cnt = -1; // Don't retry. + try + { + handler = this._proxy.__getRequestHandler(); + handler.flushAsyncBatchRequests(this); + } + catch(__ex) + { + cnt = this._proxy.__handleException(handler, __ex, 0, cnt); + } + } + }); + + Ice.ProxyBatchOutgoingAsync = ProxyBatchOutgoingAsync; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ProxyFactory.js b/js/src/Ice/ProxyFactory.js new file mode 100644 index 00000000000..5c62625a772 --- /dev/null +++ b/js/src/Ice/ProxyFactory.js @@ -0,0 +1,291 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Debug"); + require("Ice/ExUtil"); + require("Ice/HashMap"); + require("Ice/ObjectPrx"); + require("Ice/StringUtil"); + require("Ice/Identity"); + require("Ice/Reference"); + require("Ice/LocalException"); + + var Ice = global.Ice || {}; + + var Debug = Ice.Debug; + var ExUtil = Ice.ExUtil; + var HashMap = Ice.HashMap; + var ObjectPrx = Ice.ObjectPrx; + var StringUtil = Ice.StringUtil; + var Identity = Ice.Identity; + + // + // Only for use by Instance. + // + var ProxyFactory = Ice.Class({ + __init__: function(instance) + { + this._instance = instance; + + var arr = this._instance.initializationData().properties.getPropertyAsList("Ice.RetryIntervals"); + + if(arr.length > 0) + { + this._retryIntervals = []; + + for(var i = 0; i < arr.length; i++) + { + var v; + + try + { + v = StringUtil.toInt(arr[i]); + } + catch(ex) + { + v = 0; + } + + // + // If -1 is the first value, no retry and wait intervals. + // + if(i === 0 && v === -1) + { + this._retryIntervals = [ 0 ]; + break; + } + + this._retryIntervals[i] = v > 0 ? v : 0; + } + } + else + { + this._retryIntervals = [ 0 ]; + } + }, + stringToProxy: function(str) + { + var ref = this._instance.referenceFactory().createFromString(str, null); + return this.referenceToProxy(ref); + }, + proxyToString: function(proxy) + { + if(proxy !== null) + { + return proxy.__reference().toString(); + } + else + { + return ""; + } + }, + propertyToProxy: function(prefix) + { + var proxy = this._instance.initializationData().properties.getProperty(prefix); + var ref = this._instance.referenceFactory().createFromString(proxy, prefix); + return this.referenceToProxy(ref); + }, + proxyToProperty: function(proxy, prefix) + { + if(proxy !== null) + { + return proxy.__reference().toProperty(prefix); + } + else + { + return new HashMap(); + } + }, + streamToProxy: function(s, type) + { + var ident = new Identity(); + ident.__read(s); + + var ref = this._instance.referenceFactory().createFromStream(ident, s); + return this.referenceToProxy(ref, type); + }, + referenceToProxy: function(ref, type) + { + if(ref !== null) + { + var proxy = type ? new type() : new ObjectPrx(); + proxy.__setup(ref); + return proxy; + } + else + { + return null; + } + }, + proxyToStream: function(proxy, s) + { + if(proxy !== null) + { + var ref = proxy.__reference(); + ref.getIdentity().__write(s); + ref.streamWrite(s); + } + else + { + var ident = new Identity("", ""); + ident.__write(s); + } + }, + checkRetryAfterException: function(ex, ref, sleepInterval, cnt) + { + var traceLevels = this._instance.traceLevels(); + var logger = this._instance.initializationData().logger; + + // + // We don't retry batch requests because the exception might have caused + // the all the requests batched with the connection to be aborted and we + // want the application to be notified. + // + if(ref.getMode() === Ice.Reference.ModeBatchOneway || ref.getMode() === Ice.Reference.ModeBatchDatagram) + { + throw ex; + } + + if(ex instanceof Ice.ObjectNotExistException) + { + var one = ex; + + if(ref.getRouterInfo() !== null && one.operation === "ice_add_proxy") + { + // + // If we have a router, an ObjectNotExistException with an + // operation name "ice_add_proxy" indicates to the client + // that the router isn't aware of the proxy (for example, + // because it was evicted by the router). In this case, we + // must *always* retry, so that the missing proxy is added + // to the router. + // + + ref.getRouterInfo().clearCache(ref); + + if(traceLevels.retry >= 1) + { + logger.trace(traceLevels.retryCat, "retrying operation call to add proxy to router\n" + + ExUtil.toString(ex)); + } + + if(sleepInterval !== null) + { + sleepInterval.value = 0; + } + return cnt; // We must always retry, so we don't look at the retry count. + } + else if(ref.isIndirect()) + { + // + // We retry ObjectNotExistException if the reference is + // indirect. + // + + if(ref.isWellKnown()) + { + var li = ref.getLocatorInfo(); + if(li !== null) + { + li.clearCache(ref); + } + } + } + else + { + // + // For all other cases, we don't retry ObjectNotExistException. + // + throw ex; + } + } + else if(ex instanceof Ice.RequestFailedException) + { + // + // For all other cases, we don't retry ObjectNotExistException + // + throw ex; + } + + // + // There is no point in retrying an operation that resulted in a + // MarshalException. This must have been raised locally (because + // if it happened in a server it would result in an + // UnknownLocalException instead), which means there was a problem + // in this process that will not change if we try again. + // + // The most likely cause for a MarshalException is exceeding the + // maximum message size, which is represented by the the subclass + // MemoryLimitException. For example, a client can attempt to send + // a message that exceeds the maximum memory size, or accumulate + // enough batch requests without flushing that the maximum size is + // reached. + // + // This latter case is especially problematic, because if we were + // to retry a batch request after a MarshalException, we would in + // fact silently discard the accumulated requests and allow new + // batch requests to accumulate. If the subsequent batched + // requests do not exceed the maximum message size, it appears to + // the client that all of the batched requests were accepted, when + // in reality only the last few are actually sent. + // + if(ex instanceof Ice.MarshalException) + { + throw ex; + } + + ++cnt; + Debug.assert(cnt > 0); + + var interval; + if(cnt === (this._retryIntervals.length + 1) && ex instanceof Ice.CloseConnectionException) + { + // + // A close connection exception is always retried at least once, even if the retry + // limit is reached. + // + interval = 0; + } + else if(cnt > this._retryIntervals.length) + { + if(traceLevels.retry >= 1) + { + logger.trace(traceLevels.retryCat, "cannot retry operation call because retry limit has been exceeded\n" + + ExUtil.toString(ex)); + } + throw ex; + } + else + { + interval = this._retryIntervals[cnt - 1]; + } + + if(traceLevels.retry >= 1) + { + var msg = "retrying operation call"; + if(interval > 0) + { + msg += " in " + interval + "ms"; + } + msg += " because of exception\n" + ExUtil.toString(ex); + logger.trace(traceLevels.retryCat, msg); + } + + Debug.assert(sleepInterval !== null); + sleepInterval.value = interval; + + return cnt; + } + }); + + Ice.ProxyFactory = ProxyFactory; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Reference.js b/js/src/Ice/Reference.js new file mode 100644 index 00000000000..54f0927a49d --- /dev/null +++ b/js/src/Ice/Reference.js @@ -0,0 +1,2345 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/ArrayUtil"); + require("Ice/Debug"); + require("Ice/HashMap"); + require("Ice/HashUtil"); + require("Ice/ExUtil"); + require("Ice/OpaqueEndpointI"); + require("Ice/Promise"); + require("Ice/Protocol"); + require("Ice/ReferenceMode"); + require("Ice/StringUtil"); + require("Ice/BuiltinSequences"); + require("Ice/EndpointTypes"); + require("Ice/Identity"); + require("Ice/Router"); + require("Ice/Locator"); + require("Ice/LocalException"); + require("Ice/Version"); + require("Ice/PropertyNames"); + + var Ice = global.Ice || {}; + + var ArrayUtil = Ice.ArrayUtil; + var Debug = Ice.Debug; + var HashMap = Ice.HashMap; + var HashUtil = Ice.HashUtil; + var ExUtil = Ice.ExUtil; + var OpaqueEndpointI = Ice.OpaqueEndpointI; + var Promise = Ice.Promise; + var Protocol = Ice.Protocol; + var RefMode = Ice.ReferenceMode; + var StringUtil = Ice.StringUtil; + var StringSeqHelper = Ice.StringSeqHelper; + var EndpointSelectionType = Ice.EndpointSelectionType; + var Identity = Ice.Identity; + var RouterPrx = Ice.RouterPrx; + var LocatorPrx = Ice.LocatorPrx; + var PropertyNames = Ice.PropertyNames; + + var Class = Ice.Class; + + var suffixes = + [ + "EndpointSelection", + "ConnectionCached", + "PreferSecure", + "EncodingVersion", + "LocatorCacheTimeout", + "Locator", + "Router", + "CollocationOptimized" + ]; + + // + // Only for use by Instance + // + var ReferenceFactory = Class({ + __init__: function(instance, communicator) + { + this._instance = instance; + this._communicator = communicator; + this._defaultRouter = null; + this._defaultLocator = null; + }, + create: function(ident, facet, tmpl, endpoints) + { + if(ident.name.length === 0 && ident.category.length === 0) + { + return null; + } + + return this.createImpl(ident, facet, tmpl.getMode(), tmpl.getSecure(), tmpl.getProtocol(), tmpl.getEncoding(), + endpoints, null, null); + }, + createWithAdapterId: function(ident, facet, tmpl, adapterId) + { + if(ident.name.length === 0 && ident.category.length === 0) + { + return null; + } + + return this.createImpl(ident, facet, tmpl.getMode(), tmpl.getSecure(), tmpl.getProtocol(), tmpl.getEncoding(), + null, adapterId, null); + }, + createFixed: function(ident, fixedConnection) + { + if(ident.name.length === 0 && ident.category.length === 0) + { + return null; + } + + // + // Create new reference + // + var ref = new FixedReference( + this._instance, + this._communicator, + ident, + "", // Facet + fixedConnection.endpoint().datagram() ? RefMode.ModeDatagram : RefMode.ModeTwoway, + fixedConnection.endpoint().secure(), + this._instance.defaultsAndOverrides().defaultEncoding, + fixedConnection); + return ref; + }, + copy: function(r) + { + var ident = r.getIdentity(); + if(ident.name.length === 0 && ident.category.length === 0) + { + return null; + } + return r.clone(); + }, + createFromString: function(s, propertyPrefix) + { + if(s === undefined || s === null || s.length === 0) + { + return null; + } + + var delim = " \t\n\r"; + + var beg; + var end = 0; + + beg = StringUtil.findFirstNotOf(s, delim, end); + if(beg == -1) + { + throw new Ice.ProxyParseException("no non-whitespace characters found in `" + s + "'"); + } + + // + // Extract the identity, which may be enclosed in single + // or double quotation marks. + // + var idstr = null; + end = StringUtil.checkQuote(s, beg); + if(end === -1) + { + throw new Ice.ProxyParseException("mismatched quotes around identity in `" + s + "'"); + } + else if(end === 0) + { + end = StringUtil.findFirstOf(s, delim + ":@", beg); + if(end === -1) + { + end = s.length; + } + idstr = s.substring(beg, end); + } + else + { + beg++; // Skip leading quote + idstr = s.substring(beg, end); + end++; // Skip trailing quote + } + + if(beg === end) + { + throw new Ice.ProxyParseException("no identity in `" + s + "'"); + } + + // + // Parsing the identity may raise IdentityParseException. + // + var ident = this._instance.stringToIdentity(idstr); + + if(ident.name.length === 0) + { + // + // An identity with an empty name and a non-empty + // category is illegal. + // + if(ident.category.length > 0) + { + throw new Ice.IllegalIdentityException(ident); + } + // + // Treat a stringified proxy containing two double + // quotes ("") the same as an empty string, i.e., + // a null proxy, but only if nothing follows the + // quotes. + // + else if(StringUtil.findFirstNotOf(s, delim, end) != -1) + { + throw new Ice.ProxyParseException("invalid characters after identity in `" + s + "'"); + } + else + { + return null; + } + } + + var facet = ""; + var mode = RefMode.ModeTwoway; + var secure = false; + var encoding = this._instance.defaultsAndOverrides().defaultEncoding; + var protocol = Ice.Protocol_1_0; + var adapter = ""; + + while(true) + { + beg = StringUtil.findFirstNotOf(s, delim, end); + if(beg === -1) + { + break; + } + + if(s.charAt(beg) == ':' || s.charAt(beg) == '@') + { + break; + } + + end = StringUtil.findFirstOf(s, delim + ":@", beg); + if(end == -1) + { + end = s.length; + } + + if(beg == end) + { + break; + } + + var option = s.substring(beg, end); + if(option.length != 2 || option.charAt(0) != '-') + { + throw new Ice.ProxyParseException("expected a proxy option but found `" + option + "' in `" + s + "'"); + } + + // + // Check for the presence of an option argument. The + // argument may be enclosed in single or double + // quotation marks. + // + var argument = null; + var argumentBeg = StringUtil.findFirstNotOf(s, delim, end); + if(argumentBeg != -1) + { + var ch = s.charAt(argumentBeg); + if(ch != "@" && ch != ":" && ch != "-") + { + beg = argumentBeg; + end = StringUtil.checkQuote(s, beg); + if(end == -1) + { + throw new Ice.ProxyParseException("mismatched quotes around value for " + option + + " option in `" + s + "'"); + } + else if(end === 0) + { + end = StringUtil.findFirstOf(s, delim + ":@", beg); + if(end === -1) + { + end = s.length; + } + argument = s.substring(beg, end); + } + else + { + beg++; // Skip leading quote + argument = s.substring(beg, end); + end++; // Skip trailing quote + } + } + } + + // + // If any new options are added here, + // IceInternal::Reference::toString() and its derived classes must be updated as well. + // + switch(option.charAt(1)) + { + case 'f': + { + if(argument === null) + { + throw new Ice.ProxyParseException("no argument provided for -f option in `" + s + "'"); + } + + try + { + facet = StringUtil.unescapeString(argument, 0, argument.length); + } + catch(ex) + { + throw new Ice.ProxyParseException("invalid facet in `" + s + "': " + ex.message); + } + + break; + } + + case 't': + { + if(argument !== null) + { + throw new Ice.ProxyParseException("unexpected argument `" + argument + + "' provided for -t option in `" + s + "'"); + } + mode = RefMode.ModeTwoway; + break; + } + + case 'o': + { + if(argument !== null) + { + throw new Ice.ProxyParseException("unexpected argument `" + argument + + "' provided for -o option in `" + s + "'"); + } + mode = RefMode.ModeOneway; + break; + } + + case 'O': + { + if(argument !== null) + { + throw new Ice.ProxyParseException("unexpected argument `" + argument + + "' provided for -O option in `" + s + "'"); + } + mode = RefMode.ModeBatchOneway; + break; + } + + case 'd': + { + if(argument !== null) + { + throw new Ice.ProxyParseException("unexpected argument `" + argument + + "' provided for -d option in `" + s + "'"); + } + mode = RefMode.ModeDatagram; + break; + } + + case 'D': + { + if(argument !== null) + { + throw new Ice.ProxyParseException("unexpected argument `" + argument + + "' provided for -D option in `" + s + "'"); + } + mode = RefMode.ModeBatchDatagram; + break; + } + + case 's': + { + if(argument !== null) + { + throw new Ice.ProxyParseException("unexpected argument `" + argument + + "' provided for -s option in `" + s + "'"); + } + secure = true; + break; + } + + case 'e': + { + if(argument === null) + { + throw new Ice.ProxyParseException("no argument provided for -e option in `" + s + "'"); + } + + try + { + encoding = Ice.stringToEncodingVersion(argument); + } + catch(e) // VersionParseException + { + throw new Ice.ProxyParseException("invalid encoding version `" + argument + "' in `" + s + + "':\n" + e.str); + } + break; + } + + case 'p': + { + if(argument === null) + { + throw new Ice.ProxyParseException("no argument provided for -p option in `" + s + "'"); + } + + try + { + protocol = Ice.stringToProtocolVersion(argument); + } + catch(e) // VersionParseException + { + throw new Ice.ProxyParseException("invalid protocol version `" + argument + "' in `" + s + + "':\n" + e.str); + } + break; + } + + default: + { + throw new Ice.ProxyParseException("unknown option `" + option + "' in `" + s + "'"); + } + } + } + + if(beg === -1) + { + return this.createImpl(ident, facet, mode, secure, protocol, encoding, null, null, propertyPrefix); + } + + var endpoints = []; + + if(s.charAt(beg) == ':') + { + var unknownEndpoints = []; + end = beg; + + while(end < s.length && s.charAt(end) == ':') + { + beg = end + 1; + + end = beg; + while(true) + { + end = s.indexOf(':', end); + if(end == -1) + { + end = s.length; + break; + } + else + { + var quoted = false; + var quote = beg; + while(true) + { + quote = s.indexOf("\"", quote); + if(quote == -1 || end < quote) + { + break; + } + else + { + quote = s.indexOf('\"', ++quote); + if(quote == -1) + { + break; + } + else if(end < quote) + { + quoted = true; + break; + } + ++quote; + } + } + if(!quoted) + { + break; + } + ++end; + } + } + + var es = s.substring(beg, end); + var endp = this._instance.endpointFactoryManager().create(es, false); + if(endp !== null) + { + endpoints.push(endp); + } + else + { + unknownEndpoints.push(es); + } + } + if(endpoints.length === 0) + { + Debug.assert(unknownEndpoints.length > 0); + throw new Ice.EndpointParseException("invalid endpoint `" + unknownEndpoints[0] + "' in `" + s + "'"); + } + else if(unknownEndpoints.length !== 0 && + this._instance.initializationData().properties.getPropertyAsIntWithDefault("Ice.Warn.Endpoints", 1) > 0) + { + var msg = []; + msg.push("Proxy contains unknown endpoints:"); + for(var i = 0; i < unknownEndpoints.length; ++i) + { + msg.push(" `"); + msg.push(unknownEndpoints[i]); + msg.push("'"); + } + this._instance.initializationData().logger.warning(msg.join("")); + } + + return this.createImpl(ident, facet, mode, secure, protocol, encoding, endpoints, null, propertyPrefix); + } + else if(s.charAt(beg) == '@') + { + beg = StringUtil.findFirstNotOf(s, delim, beg + 1); + if(beg == -1) + { + throw new Ice.ProxyParseException("missing adapter id in `" + s + "'"); + } + + var adapterstr = null; + end = StringUtil.checkQuote(s, beg); + if(end === -1) + { + throw new Ice.ProxyParseException("mismatched quotes around adapter id in `" + s + "'"); + } + else if(end === 0) + { + end = StringUtil.findFirstOf(s, delim, beg); + if(end === -1) + { + end = s.length; + } + adapterstr = s.substring(beg, end); + } + else + { + beg++; // Skip leading quote + adapterstr = s.substring(beg, end); + end++; // Skip trailing quote + } + + if(end !== s.length && StringUtil.findFirstNotOf(s, delim, end) !== -1) + { + throw new Ice.ProxyParseException("invalid trailing characters after `" + s.substring(0, end + 1) + + "' in `" + s + "'"); + } + + try + { + adapter = StringUtil.unescapeString(adapterstr, 0, adapterstr.length); + } + catch(ex) + { + throw new Ice.ProxyParseException("invalid adapter id in `" + s + "': " + ex.message); + } + if(adapter.length === 0) + { + throw new Ice.ProxyParseException("empty adapter id in `" + s + "'"); + } + return this.createImpl(ident, facet, mode, secure, protocol, encoding, null, adapter, propertyPrefix); + } + + throw new Ice.ProxyParseException("malformed proxy `" + s + "'"); + }, + createFromStream: function(ident, s) + { + // + // Don't read the identity here. Operations calling this + // constructor read the identity, and pass it as a parameter. + // + + if(ident.name.length === 0 && ident.category.length === 0) + { + return null; + } + + // + // For compatibility with the old FacetPath. + // + var facetPath = StringSeqHelper.read(s); // String[] + var facet; + if(facetPath.length > 0) + { + if(facetPath.length > 1) + { + throw new Ice.ProxyUnmarshalException(); + } + facet = facetPath[0]; + } + else + { + facet = ""; + } + + var mode = s.readByte(); + if(mode < 0 || mode > RefMode.ModeLast) + { + throw new Ice.ProxyUnmarshalException(); + } + + var secure = s.readBool(); + + var protocol = null; + var encoding = null; + if(!s.getReadEncoding().equals(Ice.Encoding_1_0)) + { + protocol = new Ice.ProtocolVersion(); + protocol.__read(s); + encoding = new Ice.EncodingVersion(); + encoding.__read(s); + } + else + { + protocol = Ice.Protocol_1_0; + encoding = Ice.Encoding_1_0; + } + + var endpoints = null; // EndpointI[] + var adapterId = null; + + var sz = s.readSize(); + if(sz > 0) + { + endpoints = []; + for(var i = 0; i < sz; i++) + { + endpoints[i] = this._instance.endpointFactoryManager().read(s); + } + } + else + { + adapterId = s.readString(); + } + + return this.createImpl(ident, facet, mode, secure, protocol, encoding, endpoints, adapterId, null); + }, + setDefaultRouter: function(defaultRouter) + { + if(this._defaultRouter === null ? defaultRouter === null : this._defaultRouter.equals(defaultRouter)) + { + return this; + } + + var factory = new ReferenceFactory(this._instance, this._communicator); + factory._defaultLocator = this._defaultLocator; + factory._defaultRouter = defaultRouter; + return factory; + }, + getDefaultRouter: function() + { + return this._defaultRouter; + }, + setDefaultLocator: function(defaultLocator) + { + if(this._defaultLocator === null ? defaultLocator === null : this._defaultLocator.equals(defaultLocator)) + { + return this; + } + + var factory = new ReferenceFactory(this._instance, this._communicator); + factory._defaultRouter = this._defaultRouter; + factory._defaultLocator = defaultLocator; + return factory; + }, + getDefaultLocator: function() + { + return this._defaultLocator; + }, + checkForUnknownProperties: function(prefix) + { + var unknownProps = [], i, length; + // + // Do not warn about unknown properties for Ice prefixes (Ice, Glacier2, etc.) + // + for(i = 0; i < PropertyNames.clPropNames.length; ++i) + { + if(prefix.indexOf(PropertyNames.clPropNames[i] + ".") === 0) + { + return; + } + } + + var props = this._instance.initializationData().properties.getPropertiesForPrefix(prefix + "."); + for(var e = props.entries; e !== null; e = e.next) + { + var valid = false; + for(i = 0, length = suffixes.length; i < length; ++i) + { + if(e.key === prefix + "." + suffixes[i]) + { + valid = true; + break; + } + } + + if(!valid) + { + unknownProps.push(e.key); + } + } + + if(unknownProps.length > 0) + { + var message = []; + message.push("found unknown properties for proxy '"); + message.push(prefix); + message.push("':"); + for(i = 0, length = unknownProps.length; i < length; ++i) + { + message.push("\n "); + message.push(unknownProps[i]); + } + this._instance.initializationData().logger.warning(message.join("")); + } + }, + createImpl: function(ident, facet, mode, secure, protocol, encoding, endpoints, adapterId, + propertyPrefix) + { + var defaultsAndOverrides = this._instance.defaultsAndOverrides(); + + // + // Default local proxy options. + // + var locatorInfo = null; + if(this._defaultLocator !== null) + { + if(!this._defaultLocator.__reference().getEncoding().equals(encoding)) + { + locatorInfo = this._instance.locatorManager().find(this._defaultLocator.ice_encodingVersion(encoding)); + } + else + { + locatorInfo = this._instance.locatorManager().find(this._defaultLocator); + } + } + var routerInfo = this._instance.routerManager().find(this._defaultRouter); + var cacheConnection = true; + var preferSecure = defaultsAndOverrides.defaultPreferSecure; + var endpointSelection = defaultsAndOverrides.defaultEndpointSelection; + var locatorCacheTimeout = defaultsAndOverrides.defaultLocatorCacheTimeout; + + // + // Override the defaults with the proxy properties if a property prefix is defined. + // + if(propertyPrefix !== null && propertyPrefix.length > 0) + { + var properties = this._instance.initializationData().properties; + + // + // Warn about unknown properties. + // + if(properties.getPropertyAsIntWithDefault("Ice.Warn.UnknownProperties", 1) > 0) + { + this.checkForUnknownProperties(propertyPrefix); + } + + var property; + + property = propertyPrefix + ".Locator"; + var locator = LocatorPrx.uncheckedCast(this._communicator.propertyToProxy(property)); + if(locator !== null) + { + if(!locator.__reference().getEncoding().equals(encoding)) + { + locatorInfo = this._instance.locatorManager().find(locator.ice_encodingVersion(encoding)); + } + else + { + locatorInfo = this._instance.locatorManager().find(locator); + } + } + + property = propertyPrefix + ".Router"; + var router = RouterPrx.uncheckedCast(this._communicator.propertyToProxy(property)); + if(router !== null) + { + var match = ".Router"; + if(propertyPrefix.lastIndexOf(match) == propertyPrefix.length - match.length) + { + var s = "`" + property + "=" + properties.getProperty(property) + + "': cannot set a router on a router; setting ignored"; + this._instance.initializationData().logger.warning(s); + } + else + { + routerInfo = this._instance.routerManager().find(router); + } + } + + property = propertyPrefix + ".ConnectionCached"; + cacheConnection = properties.getPropertyAsIntWithDefault(property, cacheConnection ? 1 : 0) > 0; + + property = propertyPrefix + ".PreferSecure"; + preferSecure = properties.getPropertyAsIntWithDefault(property, preferSecure ? 1 : 0) > 0; + + property = propertyPrefix + ".EndpointSelection"; + if(properties.getProperty(property).length > 0) + { + var type = properties.getProperty(property); + if(type == "Random") + { + endpointSelection = EndpointSelectionType.Random; + } + else if(type == "Ordered") + { + endpointSelection = EndpointSelectionType.Ordered; + } + else + { + throw new Ice.EndpointSelectionTypeParseException("illegal value `" + type + + "'; expected `Random' or `Ordered'"); + } + } + + property = propertyPrefix + ".LocatorCacheTimeout"; + locatorCacheTimeout = properties.getPropertyAsIntWithDefault(property, locatorCacheTimeout); + } + + // + // Create new reference + // + return new RoutableReference(this._instance, + this._communicator, + ident, + facet, + mode, + secure, + protocol, + encoding, + endpoints, + adapterId, + locatorInfo, + routerInfo, + cacheConnection, + preferSecure, + endpointSelection, + locatorCacheTimeout); + } + }); + + Ice.ReferenceFactory = ReferenceFactory; + + var Reference = Class({ + __init__: function(instance, communicator, identity, facet, mode, secure, protocol, encoding) + { + // + // Validate string arguments. + // + Debug.assert(identity === undefined || identity.name !== null); + Debug.assert(identity === undefined || identity.category !== null); + Debug.assert(facet === undefined || facet !== null); + + this._instance = instance; + this._communicator = communicator; + this._mode = mode; + this._secure = secure; + this._identity = identity; + this._context = Reference._emptyContext; + this._facet = facet; + this._protocol = protocol; + this._encoding = encoding; + this._hashInitialized = false; + this._overrideCompress = false; + this._compress = false; // Only used if _overrideCompress == true + }, + getMode: function() + { + return this._mode; + }, + getSecure: function() + { + return this._secure; + }, + getProtocol: function() + { + return this._protocol; + }, + getEncoding: function() + { + return this._encoding; + }, + getIdentity: function() + { + return this._identity; + }, + getFacet: function() + { + return this._facet; + }, + getInstance: function() + { + return this._instance; + }, + getContext: function() + { + return this._context; // HashMap + }, + getCommunicator: function() + { + return this._communicator; + }, + getEndpoints: function() + { + // Abstract + Debug.assert(false); + return null; + }, + getAdapterId: function() + { + // Abstract + Debug.assert(false); + return ""; + }, + getRouterInfo: function() + { + // Abstract + Debug.assert(false); + return null; + }, + getLocatorInfo: function() + { + // Abstract + Debug.assert(false); + return null; + }, + getCacheConnection: function() + { + // Abstract + Debug.assert(false); + return false; + }, + getPreferSecure: function() + { + // Abstract + Debug.assert(false); + return false; + }, + getEndpointSelection: function() + { + // Abstract + Debug.assert(false); + return null; + }, + getLocatorCacheTimeout: function() + { + // Abstract + Debug.assert(false); + return 0; + }, + getConnectionId: function() + { + // Abstract + Debug.assert(false); + return ""; + }, + // + // The change* methods (here and in derived classes) create + // a new reference based on the existing one, with the + // corresponding value changed. + // + changeContext: function(newContext) + { + if(newContext === undefined || newContext === null) + { + newContext = Reference._emptyContext; + } + var r = this._instance.referenceFactory().copy(this); + if(newContext.size === 0) + { + r._context = Reference._emptyContext; + } + else + { + r._context = new HashMap(newContext); + } + return r; + }, + changeMode: function(newMode) + { + if(newMode === this._mode) + { + return this; + } + var r = this._instance.referenceFactory().copy(this); + r._mode = newMode; + return r; + }, + changeSecure: function(newSecure) + { + if(newSecure === this._secure) + { + return this; + } + var r = this._instance.referenceFactory().copy(this); + r._secure = newSecure; + return r; + }, + changeIdentity: function(newIdentity) + { + if(newIdentity.equals(this._identity)) + { + return this; + } + var r = this._instance.referenceFactory().copy(this); + r._identity = new Identity(newIdentity.name, newIdentity.category); + return r; + }, + changeFacet: function(newFacet) + { + if(newFacet === this._facet) + { + return this; + } + var r = this._instance.referenceFactory().copy(this); + r._facet = newFacet; + return r; + }, + changeEncoding: function(newEncoding) + { + if(newEncoding.equals(this._encoding)) + { + return this; + } + var r = this._instance.referenceFactory().copy(this); + r._encoding = newEncoding; + return r; + }, + changeCompress: function(newCompress) + { + if(this._overrideCompress && this._compress === newCompress) + { + return this; + } + var r = this._instance.referenceFactory().copy(this); + r._compress = newCompress; + r._overrideCompress = true; + return r; + }, + changeAdapterId: function(newAdapterId) + { + // Abstract + Debug.assert(false); + return null; + }, + changeEndpoints: function(newEndpoints) + { + // Abstract + Debug.assert(false); + return null; + }, + changeLocator: function(newLocator) + { + // Abstract + Debug.assert(false); + return null; + }, + changeRouter: function(newRouter) + { + // Abstract + Debug.assert(false); + return null; + }, + changeCacheConnection: function(newCache) + { + // Abstract + Debug.assert(false); + return null; + }, + changePreferSecure: function(newPreferSecure) + { + // Abstract + Debug.assert(false); + return null; + }, + changeEndpointSelection: function(newType) + { + // Abstract + Debug.assert(false); + return null; + }, + changeLocatorCacheTimeout: function(newTimeout) + { + // Abstract + Debug.assert(false); + return null; + }, + changeTimeout: function(newTimeout) + { + // Abstract + Debug.assert(false); + return null; + }, + changeConnectionId: function(connectionId) + { + // Abstract + Debug.assert(false); + return null; + }, + hashCode: function() + { + if(this._hashInitialized) + { + return this._hashValue; + } + + var h = 5381; + h = HashUtil.addNumber(h, this._mode); + h = HashUtil.addBoolean(h, this._secure); + h = HashUtil.addHashable(h, this._identity); + if(this._context !== null && this._context !== undefined) + { + for(var e = this._context.entries; e !== null; e = e.next) + { + h = HashUtil.addString(h, e.key); + h = HashUtil.addString(h, e.value); + } + } + h = HashUtil.addString(h, this._facet); + h = HashUtil.addBoolean(h, this._overrideCompress); + if(this._overrideCompress) + { + h = HashUtil.addBoolean(h, this._compress); + } + h = HashUtil.addHashable(h, this._protocol); + h = HashUtil.addHashable(h, this._encoding); + + this._hashValue = h; + this._hashInitialized = true; + + return this._hashValue; + }, + // + // Utility methods + // + isIndirect: function() + { + // Abstract + Debug.assert(false); + return false; + }, + isWellKnown: function() + { + // Abstract + Debug.assert(false); + return false; + }, + // + // Marshal the reference. + // + streamWrite: function(s) + { + // + // Don't write the identity here. Operations calling streamWrite + // write the identity. + // + + // + // For compatibility with the old FacetPath. + // + if(this._facet.length === 0) + { + s.writeSize(0); // Empty string sequence + } + else + { + s.writeSize(1); // String sequence with one element + s.writeString(this._facet); + } + + s.writeByte(this._mode); + + s.writeBool(this._secure); + + if(!s.getWriteEncoding().equals(Ice.Encoding_1_0)) + { + this._protocol.__write(s); + this._encoding.__write(s); + } + + // Derived class writes the remainder of the reference. + }, + // + // Convert the reference to its string form. + // + toString: function() + { + // + // WARNING: Certain features, such as proxy validation in Glacier2, + // depend on the format of proxy strings. Changes to toString() and + // methods called to generate parts of the reference string could break + // these features. Please review for all features that depend on the + // format of proxyToString() before changing this and related code. + // + var s = []; + + // + // If the encoded identity string contains characters which + // the reference parser uses as separators, then we enclose + // the identity string in quotes. + // + var id = this._instance.identityToString(this._identity); + if(id.search(/[ :@]/) != -1) + { + s.push('"'); + s.push(id); + s.push('"'); + } + else + { + s.push(id); + } + + if(this._facet.length > 0) + { + // + // If the encoded facet string contains characters which + // the reference parser uses as separators, then we enclose + // the facet string in quotes. + // + s.push(" -f "); + var fs = StringUtil.escapeString(this._facet, ""); + if(fs.search(/[ :@]/) != -1) + { + s.push('"'); + s.push(fs); + s.push('"'); + } + else + { + s.push(fs); + } + } + + switch(this._mode) + { + case RefMode.ModeTwoway: + { + s.push(" -t"); + break; + } + + case RefMode.ModeOneway: + { + s.push(" -o"); + break; + } + + case RefMode.ModeBatchOneway: + { + s.push(" -O"); + break; + } + + case RefMode.ModeDatagram: + { + s.push(" -d"); + break; + } + + case RefMode.ModeBatchDatagram: + { + s.push(" -D"); + break; + } + } + + if(this._secure) + { + s.push(" -s"); + } + + if(!this._protocol.equals(Ice.Protocol_1_0)) + { + // + // We only print the protocol if it's not 1.0. It's fine as + // long as we don't add Ice.Default.ProtocolVersion, a + // stringified proxy will convert back to the same proxy with + // stringToProxy. + // + s.push(" -p "); + s.push(Ice.protocolVersionToString(this._protocol)); + } + + // + // Always print the encoding version to ensure a stringified proxy + // will convert back to a proxy with the same encoding with + // stringToProxy (and won't use Ice.Default.EncodingVersion). + // + s.push(" -e "); + s.push(Ice.encodingVersionToString(this._encoding)); + + return s.join(""); + + // Derived class writes the remainder of the string. + }, + // + // Convert the reference to its property form. + // + toProperty: function(prefix) + { + // Abstract + Debug.assert(false); + return null; + }, + getConnection: function() + { + // Abstract + Debug.assert(false); + }, + equals: function(r) + { + // + // Note: if(this === r) and type test are performed by each non-abstract derived class. + // + + if(this._mode !== r._mode) + { + return false; + } + + if(this._secure !== r._secure) + { + return false; + } + + if(!this._identity.equals(r._identity)) + { + return false; + } + + if(!this._context.equals(r._context)) + { + return false; + } + + if(this._facet !== r._facet) + { + return false; + } + + if(this._overrideCompress !== r._overrideCompress) + { + return false; + } + if(this._overrideCompress && this._compress !== r._compress) + { + return false; + } + + if(!this._protocol.equals(r._protocol)) + { + return false; + } + + if(!this._encoding.equals(r._encoding)) + { + return false; + } + + return true; + }, + clone: function() + { + // Abstract + Debug.assert(false); + return null; + }, + copyMembers: function(r) + { + // + // Copy the members that are not passed to the constructor. + // + r._context = this._context; + r._overrideCompress = this._overrideCompress; + r._compress = this._compress; + } + }); + + Reference._emptyContext = new HashMap(); + Reference._emptyEndpoints = []; + + Ice.Reference = Reference; + + var FixedReference = Class(Reference, { + __init__: function(instance, communicator, identity, facet, mode, secure, encoding, connection) + { + Reference.call(this, instance, communicator, identity, facet, mode, secure, Ice.Protocol_1_0, encoding); + this._fixedConnection = connection; + }, + getEndpoints: function() + { + return Reference._emptyEndpoints; + }, + getAdapterId: function() + { + return ""; + }, + getRouterInfo: function() + { + return null; + }, + getLocatorInfo: function() + { + return null; + }, + getCacheConnection: function() + { + return false; + }, + getPreferSecure: function() + { + return false; + }, + getEndpointSelection: function() + { + return EndpointSelectionType.Random; + }, + getLocatorCacheTimeout: function() + { + return 0; + }, + getConnectionId: function() + { + return ""; + }, + changeAdapterId: function(newAdapterId) + { + throw new Ice.FixedProxyException(); + }, + changeEndpoints: function(newEndpoints) + { + throw new Ice.FixedProxyException(); + }, + changeLocator: function(newLocator) + { + throw new Ice.FixedProxyException(); + }, + changeRouter: function(newRouter) + { + throw new Ice.FixedProxyException(); + }, + changeCacheConnection: function(newCache) + { + throw new Ice.FixedProxyException(); + }, + changePreferSecure: function(prefSec) + { + throw new Ice.FixedProxyException(); + }, + changeEndpointSelection: function(newType) + { + throw new Ice.FixedProxyException(); + }, + changeLocatorCacheTimeout: function(newTimeout) + { + throw new Ice.FixedProxyException(); + }, + changeTimeout: function(newTimeout) + { + throw new Ice.FixedProxyException(); + }, + changeConnectionId: function(connectionId) + { + throw new Ice.FixedProxyException(); + }, + isIndirect: function() + { + return false; + }, + isWellKnown: function() + { + return false; + }, + streamWrite: function(s) + { + throw new Ice.FixedProxyException(); + }, + toString: function() + { + throw new Ice.FixedProxyException(); + }, + toProperty: function(prefix) + { + throw new Ice.FixedProxyException(); + }, + clone: function() + { + var r = new FixedReference(this.getInstance(), this.getCommunicator(), this.getIdentity(), this.getFacet(), + this.getMode(), this.getSecure(), this.getEncoding(), this._fixedConnection); + this.copyMembers(r); + return r; + }, + getConnectionInternal: function(compress) + { + switch(this.getMode()) + { + case RefMode.ModeTwoway: + case RefMode.ModeOneway: + case RefMode.ModeBatchOneway: + { + if(this._fixedConnection.endpoint().datagram()) + { + throw new Ice.NoEndpointException(""); + } + break; + } + + case RefMode.ModeDatagram: + case RefMode.ModeBatchDatagram: + { + if(!this._fixedConnection.endpoint().datagram()) + { + throw new Ice.NoEndpointException(""); + } + break; + } + } + + // + // If a secure connection is requested or secure overrides is set, + // check if the connection is secure. + // + var secure; + var defaultsAndOverrides = this.getInstance().defaultsAndOverrides(); + if(defaultsAndOverrides.overrideSecure) + { + secure = defaultsAndOverrides.overrideSecureValue; + } + else + { + secure = this.getSecure(); + } + if(secure && !this._fixedConnection.endpoint().secure()) + { + throw new Ice.NoEndpointException(""); + } + + this._fixedConnection.throwException(); // Throw in case our connection is already destroyed. + + if(defaultsAndOverrides.overrideCompress) + { + compress.value = defaultsAndOverrides.overrideCompressValue; + } + else if(this._overrideCompress) + { + compress.value = this._compress; + } + else + { + compress.value = this._fixedConnection.endpoint().compress(); + } + return this._fixedConnection; + }, + getConnection: function() + { + var promise = new Promise(); // success callback receives (connection, compress) + try + { + var compress = { 'value': false }; + var connection = this.getConnectionInternal(compress); + promise.succeed(connection, compress.value); + } + catch(ex) + { + promise.fail(ex); + } + return promise; + }, + equals: function(rhs) + { + if(this === rhs) + { + return true; + } + if(!(rhs instanceof FixedReference)) + { + return false; + } + if(!Reference.prototype.equals.call(this, rhs)) + { + return false; + } + return this._fixedConnection.equals(rhs._fixedConnection); + } + }); + + Ice.FixedReference = FixedReference; + + var RoutableReference = Class(Reference, { + __init__: function(instance, communicator, identity, facet, mode, secure, protocol, encoding, endpoints, + adapterId, locatorInfo, routerInfo, cacheConnection, preferSecure, endpointSelection, + locatorCacheTimeout) + { + Reference.call(this, instance, communicator, identity, facet, mode, secure, protocol, encoding); + this._endpoints = endpoints; + this._adapterId = adapterId; + this._locatorInfo = locatorInfo; + this._routerInfo = routerInfo; + this._cacheConnection = cacheConnection; + this._preferSecure = preferSecure; + this._endpointSelection = endpointSelection; + this._locatorCacheTimeout = locatorCacheTimeout; + this._overrideTimeout = false; + this._timeout = -1; + + if(this._endpoints === null) + { + this._endpoints = Reference._emptyEndpoints; + } + if(this._adapterId === null) + { + this._adapterId = ""; + } + this._connectionId = ""; + Debug.assert(this._adapterId.length === 0 || this._endpoints.length === 0); + }, + getEndpoints: function() + { + return this._endpoints; + }, + getAdapterId: function() + { + return this._adapterId; + }, + getRouterInfo: function() + { + return this._routerInfo; + }, + getLocatorInfo: function() + { + return this._locatorInfo; + }, + getCacheConnection: function() + { + return this._cacheConnection; + }, + getPreferSecure: function() + { + return this._preferSecure; + }, + getEndpointSelection: function() + { + return this._endpointSelection; + }, + getLocatorCacheTimeout: function() + { + return this._locatorCacheTimeout; + }, + getConnectionId: function() + { + return this._connectionId; + }, + changeEncoding: function(newEncoding) + { + var r = Reference.prototype.changeEncoding.call(this, newEncoding); + if(r !== this) + { + var locInfo = r._locatorInfo; + if(locInfo !== null && !locInfo.getLocator().ice_getEncodingVersion().equals(newEncoding)) + { + r._locatorInfo = this.getInstance().locatorManager().find( + locInfo.getLocator().ice_encodingVersion(newEncoding)); + } + } + return r; + }, + changeCompress: function(newCompress) + { + var r = Reference.prototype.changeCompress.call(this, newCompress); + if(r !== this && this._endpoints.length > 0) // Also override the compress flag on the endpoints if it was updated. + { + var newEndpoints = []; + for(var i = 0; i < this._endpoints.length; i++) + { + newEndpoints[i] = this._endpoints[i].changeCompress(newCompress); + } + r._endpoints = newEndpoints; + } + return r; + }, + changeAdapterId: function(newAdapterId) + { + if(this._adapterId === newAdapterId) + { + return this; + } + var r = this.getInstance().referenceFactory().copy(this); + r._adapterId = newAdapterId; + r._endpoints = Reference._emptyEndpoints; + return r; + }, + changeEndpoints: function(newEndpoints) + { + if(ArrayUtil.equals(newEndpoints, this._endpoints, function(e1, e2) { return e1.equals(e2); })) + { + return this; + } + var r = this.getInstance().referenceFactory().copy(this); + r._endpoints = newEndpoints; + r._adapterId = ""; + r.applyOverrides(r._endpoints); + return r; + }, + changeLocator: function(newLocator) + { + var newLocatorInfo = this.getInstance().locatorManager().find(newLocator); + if(newLocatorInfo !== null && this._locatorInfo !== null && newLocatorInfo.equals(this._locatorInfo)) + { + return this; + } + var r = this.getInstance().referenceFactory().copy(this); + r._locatorInfo = newLocatorInfo; + return r; + }, + changeRouter: function(newRouter) + { + var newRouterInfo = this.getInstance().routerManager().find(newRouter); + if(newRouterInfo !== null && this._routerInfo !== null && newRouterInfo.equals(this._routerInfo)) + { + return this; + } + var r = this.getInstance().referenceFactory().copy(this); + r._routerInfo = newRouterInfo; + return r; + }, + changeCacheConnection: function(newCache) + { + if(newCache === this._cacheConnection) + { + return this; + } + var r = this.getInstance().referenceFactory().copy(this); + r._cacheConnection = newCache; + return r; + }, + changePreferSecure: function(newPreferSecure) + { + if(newPreferSecure === this._preferSecure) + { + return this; + } + var r = this.getInstance().referenceFactory().copy(this); + r._preferSecure = newPreferSecure; + return r; + }, + changeEndpointSelection: function(newType) + { + if(newType === this._endpointSelection) + { + return this; + } + var r = this.getInstance().referenceFactory().copy(this); + r._endpointSelection = newType; + return r; + }, + changeLocatorCacheTimeout: function(newTimeout) + { + if(this._locatorCacheTimeout === newTimeout) + { + return this; + } + var r = this.getInstance().referenceFactory().copy(this); + r._locatorCacheTimeout = newTimeout; + return r; + }, + changeTimeout: function(newTimeout) + { + if(this._overrideTimeout && this._timeout === newTimeout) + { + return this; + } + var r = this.getInstance().referenceFactory().copy(this); + r._timeout = newTimeout; + r._overrideTimeout = true; + if(this._endpoints.length > 0) + { + var newEndpoints = []; + for(var i = 0; i < this._endpoints.length; i++) + { + newEndpoints[i] = this._endpoints[i].changeTimeout(newTimeout); + } + r._endpoints = newEndpoints; + } + return r; + }, + changeConnectionId: function(id) + { + if(this._connectionId === id) + { + return this; + } + var r = this.getInstance().referenceFactory().copy(this); + r._connectionId = id; + if(this._endpoints.length > 0) + { + var newEndpoints = []; + for(var i = 0; i < this._endpoints.length; i++) + { + newEndpoints[i] = this._endpoints[i].changeConnectionId(id); + } + r._endpoints = newEndpoints; + } + return r; + }, + isIndirect: function() + { + return this._endpoints.length === 0; + }, + isWellKnown: function() + { + return this._endpoints.length === 0 && this._adapterId.length === 0; + }, + streamWrite: function(s) + { + Reference.prototype.streamWrite.call(this, s); + + s.writeSize(this._endpoints.length); + if(this._endpoints.length > 0) + { + Debug.assert(this._adapterId.length === 0); + for(var i = 0; i < this._endpoints.length; ++i) + { + this._endpoints[i].streamWrite(s); + } + } + else + { + s.writeString(this._adapterId); // Adapter id. + } + }, + toString: function() + { + // + // WARNING: Certain features, such as proxy validation in Glacier2, + // depend on the format of proxy strings. Changes to toString() and + // methods called to generate parts of the reference string could break + // these features. Please review for all features that depend on the + // format of proxyToString() before changing this and related code. + // + var s = []; + s.push(Reference.prototype.toString.call(this)); + if(this._endpoints.length > 0) + { + for(var i = 0; i < this._endpoints.length; ++i) + { + var endp = this._endpoints[i].toString(); + if(endp !== null && endp.length > 0) + { + s.push(':'); + s.push(endp); + } + } + } + else if(this._adapterId.length > 0) + { + s.push(" @ "); + + // + // If the encoded adapter id string contains characters which + // the reference parser uses as separators, then we enclose + // the adapter id string in quotes. + // + var a = StringUtil.escapeString(this._adapterId, null); + if(a.search(/[ :@]/) != -1) + { + s.push('"'); + s.push(a); + s.push('"'); + } + else + { + s.push(a); + } + } + return s.join(""); + }, + toProperty: function(prefix) + { + var properties = new HashMap(), e; + + properties.set(prefix, this.toString()); + properties.set(prefix + ".CollocationOptimized", "0"); + properties.set(prefix + ".ConnectionCached", this._cacheConnection ? "1" : "0"); + properties.set(prefix + ".PreferSecure", this._preferSecure ? "1" : "0"); + properties.set(prefix + ".EndpointSelection", + this._endpointSelection === EndpointSelectionType.Random ? "Random" : "Ordered"); + + properties.set(prefix + ".LocatorCacheTimeout", "" + this._locatorCacheTimeout); + + if(this._routerInfo !== null) + { + var h = this._routerInfo.getRouter(); + var routerProperties = h.__reference().toProperty(prefix + ".Router"); + for(e = routerProperties.entries; e !== null; e = e.next) + { + properties.set(e.key, e.value); + } + } + + if(this._locatorInfo !== null) + { + var p = this._locatorInfo.getLocator(); + var locatorProperties = p.__reference().toProperty(prefix + ".Locator"); + for(e = locatorProperties.entries; e !== null; e = e.next) + { + properties.set(e.key, e.value); + } + } + + return properties; + }, + hashCode: function() + { + if(!this._hashInitialized) + { + Reference.prototype.hashCode.call(this); // Initializes _hashValue. + this._hashValue = HashUtil.addString(this._hashValue, this._adapterId); + } + return this._hashValue; + }, + equals: function(rhs) + { + if(this === rhs) + { + return true; + } + if(!(rhs instanceof RoutableReference)) + { + return false; + } + + if(!Reference.prototype.equals.call(this, rhs)) + { + return false; + } + + if(this._locatorInfo === null ? rhs._locatorInfo !== null : !this._locatorInfo.equals(rhs._locatorInfo)) + { + return false; + } + if(this._routerInfo === null ? rhs._routerInfo !== null : !this._routerInfo.equals(rhs._routerInfo)) + { + return false; + } + if(this._cacheConnection !== rhs._cacheConnection) + { + return false; + } + if(this._preferSecure !== rhs._preferSecure) + { + return false; + } + if(this._endpointSelection !== rhs._endpointSelection) + { + return false; + } + if(this._locatorCacheTimeout !== rhs._locatorCacheTimeout) + { + return false; + } + if(this._connectionId !== rhs._connectionId) + { + return false; + } + if(this._overrideTimeout !== rhs._overrideTimeout) + { + return false; + } + if(this._overrideTimeout && this._timeout !== rhs._timeout) + { + return false; + } + if(!ArrayUtil.equals(this._endpoints, rhs._endpoints, function(e1, e2) { return e1.equals(e2); })) + { + return false; + } + if(this._adapterId !== rhs._adapterId) + { + return false; + } + return true; + }, + getConnection: function() + { + var promise = new Promise(); // success callback receives (connection, compress) + + if(this._routerInfo !== null) + { + // + // If we route, we send everything to the router's client + // proxy endpoints. + // + var self = this; + this._routerInfo.getClientEndpoints().then( + function(endpts) + { + if(endpts.length > 0) + { + self.applyOverrides(endpts); + self.createConnection(endpts).then( + function(connection, compress) + { + promise.succeed(connection, compress); + }, + function(ex) + { + promise.fail(ex); + }); + } + else + { + self.getConnectionNoRouterInfo(promise); + } + }).exception( + function(ex) + { + promise.fail(ex); + }); + } + else + { + this.getConnectionNoRouterInfo(promise); + } + + return promise; + }, + getConnectionNoRouterInfo: function(promise) + { + if(this._endpoints.length > 0) + { + this.createConnection(this._endpoints).then( + function(connection, compress) + { + promise.succeed(connection, compress); + }).exception( + function(ex) + { + promise.fail(ex); + }); + return; + } + + var self = this; + if(this._locatorInfo !== null) + { + this._locatorInfo.getEndpoints(this, null, this._locatorCacheTimeout).then( + function(endpoints, cached) + { + if(endpoints.length === 0) + { + promise.fail(new Ice.NoEndpointException(self.toString())); + return; + } + + self.applyOverrides(endpoints); + self.createConnection(endpoints).then( + function(connection, compress) + { + promise.succeed(connection, compress); + }, + function(ex) + { + if(ex instanceof Ice.NoEndpointException) + { + // + // No need to retry if there's no endpoints. + // + promise.fail(ex); + } + else + { + Debug.assert(self._locatorInfo !== null); + self.getLocatorInfo().clearCache(self); + if(cached) + { + var traceLevels = self.getInstance().traceLevels(); + if(traceLevels.retry >= 2) + { + var s = "connection to cached endpoints failed\n" + + "removing endpoints from cache and trying one more time\n" + + ExUtil.toString(ex); + self.getInstance().initializationData().logger.trace( + traceLevels.retryCat, s); + } + self.getConnectionNoRouterInfo(promise); // Retry. + return; + } + promise.fail(ex); + } + }); + }).exception( + function(ex) + { + promise.fail(ex); + }); + } + else + { + promise.fail(new Ice.NoEndpointException(this.toString())); + } + }, + clone: function() + { + var r = new RoutableReference(this.getInstance(), this.getCommunicator(), this.getIdentity(), this.getFacet(), + this.getMode(), this.getSecure(), this.getProtocol(), this.getEncoding(), + this._endpoints, this._adapterId, this._locatorInfo, this._routerInfo, + this._cacheConnection, this._preferSecure, this._endpointSelection, + this._locatorCacheTimeout); + this.copyMembers(r); + return r; + }, + copyMembers: function(rhs) + { + // + // Copy the members that are not passed to the constructor. + // + Reference.prototype.copyMembers.call(this, rhs); + rhs._overrideTimeout = this._overrideTimeout; + rhs._timeout = this._timeout; + rhs._connectionId = this._connectionId; + }, + applyOverrides: function(endpts) + { + // + // Apply the endpoint overrides to each endpoint. + // + for(var i = 0; i < endpts.length; ++i) + { + endpts[i] = endpts[i].changeConnectionId(this._connectionId); + if(this._overrideCompress) + { + endpts[i] = endpts[i].changeCompress(this._compress); + } + if(this._overrideTimeout) + { + endpts[i] = endpts[i].changeTimeout(this._timeout); + } + } + }, + filterEndpoints: function(allEndpoints) + { + var endpoints = []; + + // + // Filter out opaque endpoints. + // + for(var i = 0; i < allEndpoints.length; ++i) + { + if(!(allEndpoints[i] instanceof OpaqueEndpointI)) + { + endpoints.push(allEndpoints[i]); + } + } + + // + // Filter out endpoints according to the mode of the reference. + // + switch(this.getMode()) + { + case RefMode.ModeTwoway: + case RefMode.ModeOneway: + case RefMode.ModeBatchOneway: + { + // + // Filter out datagram endpoints. + // + endpoints = ArrayUtil.filter(endpoints, function(e, index, arr) { return !e.datagram(); }); + break; + } + + case RefMode.ModeDatagram: + case RefMode.ModeBatchDatagram: + { + // + // Filter out non-datagram endpoints. + // + endpoints = ArrayUtil.filter(endpoints, function(e, index, arr) { return e.datagram(); }); + break; + } + } + + // + // Sort the endpoints according to the endpoint selection type. + // + switch(this.getEndpointSelection()) + { + case EndpointSelectionType.Random: + { + // + // Shuffle the endpoints. + // + ArrayUtil.shuffle(endpoints); + break; + } + case EndpointSelectionType.Ordered: + { + // Nothing to do. + break; + } + default: + { + Debug.assert(false); + break; + } + } + + // + // If a secure connection is requested or secure overrides is + // set, remove all non-secure endpoints. Otherwise if preferSecure is set + // make secure endpoints prefered. By default make non-secure + // endpoints preferred over secure endpoints. + // + var overrides = this.getInstance().defaultsAndOverrides(); + if(overrides.overrideSecure ? overrides.overrideSecureValue : this.getSecure()) + { + endpoints = ArrayUtil.filter(endpoints, function(e, index, arr) { return e.secure(); }); + } + else + { + var preferSecure = this.getPreferSecure(); + var compare = function(e1, e2) + { + var ls = e1.secure(); + var rs = e2.secure(); + if((ls && rs) || (!ls && !rs)) + { + return 0; + } + else if(!ls && rs) + { + return preferSecure ? 1 : -1; + } + else + { + return preferSecure ? -1 : 1; + } + }; + endpoints.sort(compare); + } + return endpoints; + }, + createConnection: function(allEndpoints) + { + var endpoints = this.filterEndpoints(allEndpoints); + if(endpoints.length === 0) + { + return new Promise().fail(new Ice.NoEndpointException(this.toString())); + } + + // + // Finally, create the connection. + // + var promise = new Promise(); + var factory = this.getInstance().outgoingConnectionFactory(); + var cb; + if(this.getCacheConnection() || endpoints.length == 1) + { + // + // Get an existing connection or create one if there's no + // existing connection to one of the given endpoints. + // + cb = new CreateConnectionCallback(this, null, promise); + factory.create(endpoints, false, this.getEndpointSelection()).then( + function(connection, compress) + { + cb.setConnection(connection, compress); + }).exception( + function(ex) + { + cb.setException(ex); + }); + } + else + { + // + // Go through the list of endpoints and try to create the + // connection until it succeeds. This is different from just + // calling create() with the given endpoints since this might + // create a new connection even if there's an existing + // connection for one of the endpoints. + // + var v = [ endpoints[0] ]; + cb = new CreateConnectionCallback(this, endpoints, promise); + factory.create(v, true, this.getEndpointSelection()).then( + function(connection, compress) + { + cb.setConnection(connection, compress); + }).exception( + function(ex) + { + cb.setException(ex); + }); + } + + return promise; + } + }); + + Ice.RoutableReference = RoutableReference; + global.Ice = Ice; + + var CreateConnectionCallback = Class({ + __init__: function(r, endpoints, promise) + { + this.ref = r; + this.endpoints = endpoints; + this.promise = promise; + this.i = 0; + this.exception = null; + }, + setConnection: function(connection, compress) + { + // + // If we have a router, set the object adapter for this router + // (if any) to the new connection, so that callbacks from the + // router can be received over this new connection. + // + if(this.ref.getRouterInfo() !== null && this.ref.getRouterInfo().getAdapter() !== null) + { + connection.setAdapter(this.ref.getRouterInfo().getAdapter()); + } + this.promise.succeed(connection, compress); + }, + setException: function(ex) + { + if(this.exception === null) + { + this.exception = ex; + } + + if(this.endpoints === null || ++this.i === this.endpoints.length) + { + this.promise.fail(this.exception); + return; + } + + var more = this.i != this.endpoints.length - 1; + var arr = [ this.endpoints[this.i] ]; + var self = this; + this.ref.getInstance().outgoingConnectionFactory().create(arr, more, this.ref.getEndpointSelection()).then( + function(connection, compress) + { + self.setConnection(connection, compress); + }).exception( + function(ex) + { + self.setException(ex); + }); + } + }); +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ReferenceMode.js b/js/src/Ice/ReferenceMode.js new file mode 100644 index 00000000000..4a6de00fd7a --- /dev/null +++ b/js/src/Ice/ReferenceMode.js @@ -0,0 +1,30 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + var Ice = global.Ice || {}; + + // + // Using a separate module for these constants so that ObjectPrx does + // not need to include Reference. + // + var ReferenceMode = + { + ModeTwoway: 0, + ModeOneway: 1, + ModeBatchOneway: 2, + ModeDatagram: 3, + ModeBatchDatagram: 4, + ModeLast: 4 + }; + + Ice.ReferenceMode = ReferenceMode; + + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/RetryQueue.js b/js/src/Ice/RetryQueue.js new file mode 100644 index 00000000000..5462933c15f --- /dev/null +++ b/js/src/Ice/RetryQueue.js @@ -0,0 +1,83 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Debug"); + require("Ice/LocalException"); + + var Ice = global.Ice || {}; + + var Debug = Ice.Debug; + + var Class = Ice.Class; + + var RetryQueue = Class({ + __init__: function(instance) + { + this._instance = instance; + this._requests = []; + }, + add: function(outAsync, interval) + { + var task = new RetryTask(this, outAsync); + this._instance.timer().schedule(function() + { + task.run(); + }, interval); + this._requests.push(task); + }, + destroy: function() + { + for(var i = 0; i < this._requests.length; ++i) + { + this._requests[i].destroy(); + } + this._requests = []; + }, + remove: function(task) + { + var idx = this._requests.indexOf(task); + if(idx >= 0) + { + this._requests.splice(idx, 1); + return true; + } + return false; + } + }); + Ice.RetryQueue = RetryQueue; + + var RetryTask = Class({ + __init__: function(queue, outAsync, interval) + { + this.queue = queue; + this.outAsync = outAsync; + }, + run: function() + { + if(this.queue.remove(this)) + { + try + { + this.outAsync.__send(); + } + catch(ex) + { + this.outAsync.__exception(ex); + } + } + }, + destroy: function() + { + this.outAsync.__exception(new Ice.CommunicatorDestroyedException()); + } + }); + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/RouterInfo.js b/js/src/Ice/RouterInfo.js new file mode 100644 index 00000000000..1a15ee3c414 --- /dev/null +++ b/js/src/Ice/RouterInfo.js @@ -0,0 +1,229 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/ArrayUtil"); + require("Ice/Debug"); + require("Ice/HashMap"); + require("Ice/Promise"); + require("Ice/LocalException"); + require("Ice/Exception"); + + var Ice = global.Ice || {}; + + var ArrayUtil = Ice.ArrayUtil; + var Debug = Ice.Debug; + var HashMap = Ice.HashMap; + var Promise = Ice.Promise; + + var RouterInfo = Ice.Class({ + __init__: function(router) + { + this._router = router; + + Debug.assert(this._router !== null); + + this._clientEndpoints = null; + this._serverEndpoints = null; + this._adapter = null; + this._identities = new HashMap(); // Set<Identity> = Map<Identity, 1> + this._identities.keyComparator = HashMap.compareEquals; + this._evictedIdentities = []; + }, + destroy: function() + { + this._clientEndpoints = []; + this._serverEndpoints = []; + this._adapter = null; + this._identities.clear(); + }, + equals: function(rhs) + { + if(this === rhs) + { + return true; + } + + if(rhs instanceof RouterInfo) + { + return this._router.equals(rhs._router); + } + + return false; + }, + hashCode: function() + { + return this._router.hashCode(); + }, + getRouter: function() + { + // + // No mutex lock necessary, _router is immutable. + // + return this._router; + }, + getClientEndpoints: function() + { + var promise = new Promise(); + + if(this._clientEndpoints !== null) + { + promise.succeed(this._clientEndpoints); + } + else + { + var self = this; + this._router.getClientProxy().then( + function(clientProxy) + { + self.setClientEndpoints(clientProxy, promise); + }).exception( + function(ex) + { + promise.fail(ex); + }); + } + + return promise; + }, + getServerEndpoints: function() + { + if(this._serverEndpoints !== null) // Lazy initialization. + { + return new Promise().succeed(this._serverEndpoints); + } + else + { + var self = this; + return this._router.getServerProxy().then( + function(proxy) + { + return self.setServerEndpoints(proxy); + }); + } + }, + addProxy: function(proxy) + { + Debug.assert(proxy !== null); + + if(this._identities.has(proxy.ice_getIdentity())) + { + // + // Only add the proxy to the router if it's not already in our local map. + // + return new Promise().succeed(); + } + else + { + var self = this; + return this._router.addProxies([ proxy ]).then( + function(evictedProxies) + { + self.addAndEvictProxies(proxy, evictedProxies); + }); + } + }, + setAdapter: function(adapter) + { + this._adapter = adapter; + }, + getAdapter: function() + { + return this._adapter; + }, + clearCache: function(ref) + { + this._identities.delete(ref.getIdentity()); + }, + setClientEndpoints: function(clientProxy, promise) + { + if(this._clientEndpoints === null) + { + if(clientProxy === null) + { + // + // If getClientProxy() return nil, use router endpoints. + // + this._clientEndpoints = this._router.__reference().getEndpoints(); + promise.succeed(this._clientEndpoints); + } + else + { + clientProxy = clientProxy.ice_router(null); // The client proxy cannot be routed. + + // + // In order to avoid creating a new connection to the + // router, we must use the same timeout as the already + // existing connection. + // + var self = this; + this._router.ice_getConnection().then( + function(con) + { + var proxy = clientProxy.ice_timeout(con.timeout()); + self._clientEndpoints = proxy.__reference().getEndpoints(); + promise.succeed(self._clientEndpoints); + }).exception( + function(ex) + { + promise.fail(ex); + }); + } + } + else + { + promise.succeed(this._clientEndpoints); + } + }, + setServerEndpoints: function(serverProxy) + { + if(serverProxy === null) + { + throw new Ice.NoEndpointException(); + } + + serverProxy = serverProxy.ice_router(null); // The server proxy cannot be routed. + this._serverEndpoints = serverProxy.__reference().getEndpoints(); + return this._serverEndpoints; + }, + addAndEvictProxies: function(proxy, evictedProxies) + { + // + // Check if the proxy hasn't already been evicted by a + // concurrent addProxies call. If it's the case, don't + // add it to our local map. + // + var index = ArrayUtil.indexOf(this._evictedIdentities, proxy.ice_getIdentity(), + function(i1, i2) { return i1.equals(i2); }); + if(index >= 0) + { + this._evictedIdentities.splice(index, 1); + } + else + { + // + // If we successfully added the proxy to the router, + // we add it to our local map. + // + this._identities.set(proxy.ice_getIdentity(), 1); + } + + // + // We also must remove whatever proxies the router evicted. + // + for(var i = 0; i < evictedProxies.length; ++i) + { + this._identities.delete(evictedProxies[i].ice_getIdentity()); + } + } + }); + Ice.RouterInfo = RouterInfo; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/RouterManager.js b/js/src/Ice/RouterManager.js new file mode 100644 index 00000000000..74156908bdd --- /dev/null +++ b/js/src/Ice/RouterManager.js @@ -0,0 +1,77 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/HashMap"); + require("Ice/RouterInfo"); + require("Ice/Router"); + + var Ice = global.Ice || {}; + + var HashMap = Ice.HashMap; + var RouterInfo = Ice.RouterInfo; + var RouterPrx = Ice.RouterPrx; + + var RouterManager = Ice.Class({ + __init__: function() + { + this._table = new HashMap(); // Map<Ice.RouterPrx, RouterInfo> + this._table.keyComparator = HashMap.compareEquals; + }, + destroy: function() + { + for(var e = this._table.entries; e !== null; e = e.next) + { + e.value.destroy(); + } + this._table.clear(); + }, + // + // Returns router info for a given router. Automatically creates + // the router info if it doesn't exist yet. + // + find: function(rtr) + { + if(rtr === null) + { + return null; + } + + // + // The router cannot be routed. + // + var router = RouterPrx.uncheckedCast(rtr.ice_router(null)); + + var info = this._table.get(router); + if(info === undefined) + { + info = new RouterInfo(router); + this._table.set(router, info); + } + + return info; + }, + erase: function(rtr) + { + var info = null; + if(rtr !== null) + { + // The router cannot be routed. + var router = RouterPrx.uncheckedCast(rtr.ice_router(null)); + + info = this._table.get(router); + this._table.delete(router); + } + return info; + } + }); + Ice.RouterManager = RouterManager; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/ServantManager.js b/js/src/Ice/ServantManager.js new file mode 100644 index 00000000000..fef9f26c0e2 --- /dev/null +++ b/js/src/Ice/ServantManager.js @@ -0,0 +1,297 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Debug"); + require("Ice/ExUtil"); + require("Ice/HashMap"); + require("Ice/LocalException"); + require("Ice/StringUtil"); + + var Ice = global.Ice || {}; + + var Debug = Ice.Debug; + var ExUtil = Ice.ExUtil; + var HashMap = Ice.HashMap; + var StringUtil = Ice.StringUtil; + + // + // Only for use by Ice.ObjectAdatperI. + // + var ServantManager = Ice.Class({ + __init__: function(instance, adapterName) + { + this._instance = instance; + this._adapterName = adapterName; + this._servantMapMap = new HashMap(); // Map<Ice.Identity, Map<String, Ice.Object> > + this._servantMapMap.keyComparator = HashMap.compareEquals; + this._defaultServantMap = new HashMap(); // Map<String, Ice.Object> + this._locatorMap = new HashMap(); // Map<String, Ice.ServantLocator> + }, + addServant: function(servant, ident, facet) + { + Debug.assert(this._instance !== null); // Must not be called after destruction. + + if(facet === null) + { + facet = ""; + } + + var m = this._servantMapMap.get(ident); + if(m === undefined) + { + m = new HashMap(); + this._servantMapMap.set(ident, m); + } + else + { + if(m.has(facet)) + { + var ex = new Ice.AlreadyRegisteredException(); + ex.id = this._instance.identityToString(ident); + ex.kindOfObject = "servant"; + if(facet.length > 0) + { + ex.id += " -f " + StringUtil.escapeString(facet, ""); + } + throw ex; + } + } + + m.set(facet, servant); + }, + addDefaultServant: function(servant, category) + { + Debug.assert(this._instance !== null); // Must not be called after destruction + + var obj = this._defaultServantMap.get(category); + if(obj !== undefined) + { + var ex = new Ice.AlreadyRegisteredException(); + ex.kindOfObject = "default servant"; + ex.id = category; + throw ex; + } + + this._defaultServantMap.set(category, servant); + }, + removeServant: function(ident, facet) + { + Debug.assert(this._instance !== null); // Must not be called after destruction. + + if(facet === null) + { + facet = ""; + } + + var m = this._servantMapMap.get(ident); + if(m === undefined || !m.has(facet)) + { + var ex = new Ice.NotRegisteredException(); + ex.id = this._instance.identityToString(ident); + ex.kindOfObject = "servant"; + if(facet.length > 0) + { + ex.id += " -f " + StringUtil.escapeString(facet, ""); + } + throw ex; + } + + var obj = m.get(facet); + m.delete(facet); + + if(m.size === 0) + { + this._servantMapMap.delete(ident); + } + + return obj; + }, + removeDefaultServant: function(category) + { + Debug.assert(this._instance !== null); // Must not be called after destruction. + + var obj = this._defaultServantMap.get(category); + if(obj === undefined) + { + var ex = new Ice.NotRegisteredException(); + ex.kindOfObject = "default servant"; + ex.id = category; + throw ex; + } + + this._defaultServantMap.delete(category); + return obj; + }, + removeAllFacets: function(ident) + { + Debug.assert(this._instance !== null); // Must not be called after destruction. + + var m = this._servantMapMap.get(ident); + if(m === undefined) + { + var ex = new Ice.NotRegisteredException(); + ex.id = this._instance.identityToString(ident); + ex.kindOfObject = "servant"; + throw ex; + } + + this._servantMapMap.delete(ident); + + return m; + }, + findServant: function(ident, facet) + { + // + // This assert is not valid if the adapter dispatch incoming + // requests from bidir connections. This method might be called if + // requests are received over the bidir connection after the + // adapter was deactivated. + // + //Debug.assert(this._instance !== null); // Must not be called after destruction. + + if(facet === null) + { + facet = ""; + } + + var m = this._servantMapMap.get(ident); + var obj = null; + if(m === undefined) + { + obj = this._defaultServantMap.get(ident.category); + if(obj === undefined) + { + obj = this._defaultServantMap.get(""); + } + } + else + { + obj = m.get(facet); + } + + return obj === undefined ? null : obj; + }, + findDefaultServant: function(category) + { + Debug.assert(this._instance !== null); // Must not be called after destruction. + + var ds = this._defaultServantMap.get(category); + return ds === undefined ? null : ds; + }, + findAllFacets: function(ident) + { + Debug.assert(this._instance !== null); // Must not be called after destruction. + + var m = this._servantMapMap.get(ident); + if(m !== undefined) + { + return m.clone(); + } + + return new HashMap(); + }, + hasServant: function(ident) + { + // + // This assert is not valid if the adapter dispatch incoming + // requests from bidir connections. This method might be called if + // requests are received over the bidir connection after the + // adapter was deactivated. + // + //Debug.assert(this._instance !== null); // Must not be called after destruction. + + var m = this._servantMapMap.get(ident); + if(m === undefined) + { + return false; + } + else + { + Debug.assert(m.size > 0); + return true; + } + }, + addServantLocator: function(locator, category) + { + Debug.assert(this._instance !== null); // Must not be called after destruction. + + var l = this._locatorMap.get(category); + if(l !== undefined) + { + var ex = new Ice.AlreadyRegisteredException(); + ex.id = StringUtil.escapeString(category, ""); + ex.kindOfObject = "servant locator"; + throw ex; + } + + this._locatorMap.set(category, locator); + }, + removeServantLocator: function(category) + { + Debug.assert(this._instance !== null); // Must not be called after destruction. + + var l = this._locatorMap.get(category); + if(l === undefined) + { + var ex = new Ice.NotRegisteredException(); + ex.id = StringUtil.escapeString(category, ""); + ex.kindOfObject = "servant locator"; + throw ex; + } + this._locatorMap.delete(category); + return l; + }, + findServantLocator: function(category) + { + // + // This assert is not valid if the adapter dispatch incoming + // requests from bidir connections. This method might be called if + // requests are received over the bidir connection after the + // adapter was deactivated. + // + //Debug.assert(this._instance !== null); // Must not be called after destruction. + + var l = this._locatorMap.get(category); + return l === undefined ? null : l; + }, + // + // Only for use by Ice.ObjectAdapterI. + // + destroy: function() + { + Debug.assert(this._instance !== null); // Must not be called after destruction. + var logger = this._instance.initializationData().logger; + this._servantMapMap.clear(); + + var locatorMap = this._locatorMap.clone(); + this._locatorMap.clear(); + this._instance = null; + + for(var e = locatorMap.entries; e !== null; e = e.next) + { + var locator = e.value; + try + { + locator.deactivate(e.key); + } + catch(ex) + { + var s = "exception during locator deactivation:\n" + "object adapter: `" + this._adapterName + + "'\n" + "locator category: `" + e.key + "'\n" + ExUtil.toString(ex); + logger.error(s); + } + } + } + }); + + Ice.ServantManager = ServantManager; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/SocketOperation.js b/js/src/Ice/SocketOperation.js new file mode 100644 index 00000000000..6e45a494dcf --- /dev/null +++ b/js/src/Ice/SocketOperation.js @@ -0,0 +1,23 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + var Ice = global.Ice || {}; + + var SocketOperation = + { + None: 0, + Read: 1, + Write: 2, + Connect: 2 // Same as Write + }; + + Ice.SocketOperation = SocketOperation; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/StreamHelpers.js b/js/src/Ice/StreamHelpers.js new file mode 100644 index 00000000000..6fcce91a4d0 --- /dev/null +++ b/js/src/Ice/StreamHelpers.js @@ -0,0 +1,327 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/HashMap"); + require("Ice/OptionalFormat"); + + var Ice = global.Ice || {}; + + var Class = Ice.Class; + var defineProperty = Object.defineProperty; + + var HashMap = Ice.HashMap; + var OptionalFormat = Ice.OptionalFormat; + + var StreamHelpers = {}; + + StreamHelpers.FSizeOptHelper = function() + { + this.writeOpt = function(os, tag, v) + { + if(v !== undefined && os.writeOpt(tag, OptionalFormat.FSize)) + { + var pos = os.startSize(); + this.write(os, v); + os.endSize(pos); + } + }; + + this.readOpt = function(is, tag) + { + var v; + if(is.readOpt(tag, OptionalFormat.FSize)) + { + is.skip(4); + v = this.read(is); + } + return v; + }; + }; + + StreamHelpers.VSizeOptHelper = function() + { + this.writeOpt = function(os, tag, v) + { + if(v !== undefined && os.writeOpt(tag, OptionalFormat.VSize)) + { + os.writeSize(this.minWireSize); + this.write(os, v); + } + }; + + this.readOpt = function(is, tag) + { + var v; + if(is.readOpt(tag, OptionalFormat.VSize)) + { + is.skipSize(); + v = this.read(is); + } + return v; + }; + }; + + StreamHelpers.VSizeContainerOptHelper = function(elementSize) + { + this.writeOpt = function(os, tag, v) + { + if(v !== undefined && os.writeOpt(tag, OptionalFormat.VSize)) + { + var sz = this.size(v); + os.writeSize(sz > 254 ? sz * elementSize + 5 : sz * elementSize + 1); + this.write(os, v); + } + }; + + this.readOpt = function(is, tag) + { + var v; + if(is.readOpt(tag, OptionalFormat.VSize)) + { + is.skipSize(); + v = this.read(is); + } + return v; + }; + }; + + StreamHelpers.VSizeContainer1OptHelper = function() + { + this.writeOpt = function(os, tag, v) + { + if(v !== undefined && os.writeOpt(tag, OptionalFormat.VSize)) + { + this.write(os, v); + } + }; + + this.readOpt = function(is, tag) + { + var v; + if(is.readOpt(tag, OptionalFormat.VSize)) + { + v = this.read(is); + } + return v; + }; + }; + + // + // Sequence helper to write sequences + // + var SequenceHelper = Class({ + write: function(os, v) + { + if(v === null || v.length === 0) + { + os.writeSize(0); + } + else + { + var helper = this.elementHelper; + os.writeSize(v.length); + for(var i = 0; i < v.length; ++i) + { + helper.write(os, v[i]); + } + } + }, + read: function(is) + { + var helper = this.elementHelper; // Cache the element helper. + var sz = is.readAndCheckSeqSize(helper.minWireSize); + var v = []; + v.length = sz; + for(var i = 0; i < sz; ++i) + { + v[i] = helper.read(is); + } + return v; + }, + size: function(v) + { + return (v === null || v === undefined) ? 0 : v.length; + } + }); + + defineProperty(SequenceHelper.prototype, "minWireSize", { + get: function(){ return 1; } + }); + + // Speacialization optimized for ByteSeq + var byteSeqHelper = new SequenceHelper(); + byteSeqHelper.write = function(os, v) { return os.writeByteSeq(v); }; + byteSeqHelper.read = function(is) { return is.readByteSeq(); }; + defineProperty(byteSeqHelper, "elementHelper", { + get: function(){ return Ice.ByteHelper; } + }); + StreamHelpers.VSizeContainer1OptHelper.call(byteSeqHelper); + + // Read method for object sequences + var objectSequenceHelperRead = function(is) + { + var sz = is.readAndCheckSeqSize(1); + var v = []; + v.length = sz; + var elementType = this.elementType; + var readObjectAtIndex = function(idx) + { + is.readObject(function(obj) { v[idx] = obj; }, elementType); + }; + + for(var i = 0; i < sz; ++i) + { + readObjectAtIndex(i); + } + return v; + }; + + StreamHelpers.generateSeqHelper = function(elementHelper, fixed, elementType) + { + if(elementHelper === Ice.ByteHelper) + { + return byteSeqHelper; + } + + var helper = new SequenceHelper(); + if(fixed) + { + if(elementHelper.minWireSize === 1) + { + StreamHelpers.VSizeContainer1OptHelper.call(helper); + } + else + { + StreamHelpers.VSizeContainerOptHelper.call(helper, elementHelper.minWireSize); + } + } + else + { + StreamHelpers.FSizeOptHelper.call(helper); + } + + defineProperty(helper, "elementHelper", { + get: function(){ return elementHelper; } + }); + + if(elementHelper == Ice.ObjectHelper) + { + defineProperty(helper, "elementType", { + get: function(){ return elementType; } + }); + helper.read = objectSequenceHelperRead; + } + + return helper; + }; + + // + // Dictionary helper to write dictionaries + // + var DictionaryHelper = Class({ + write: function(os, v) + { + if(v === null || v.size === 0) + { + os.writeSize(0); + } + else + { + var keyHelper = this.keyHelper; + var valueHelper = this.valueHelper; + os.writeSize(v.size); + for(var e = v.entries; e !== null; e = e.next) + { + keyHelper.write(os, e.key); + valueHelper.write(os, e.value); + } + } + }, + read: function(is) + { + var mapType = this.mapType; + var v = new mapType(); + var sz = is.readSize(); + var keyHelper = this.keyHelper; + var valueHelper = this.valueHelper; + for(var i = 0; i < sz; ++i) + { + v.set(keyHelper.read(is), valueHelper.read(is)); + } + return v; + }, + size: function(v) + { + return (v === null || v === undefined) ? 0 : v.size; + } + }); + + Object.defineProperty(DictionaryHelper.prototype, "minWireSize", { + get: function(){ return 1; } + }); + + // Read method for dictionaries of objects + var objectDictionaryHelperRead = function(is) + { + var sz = is.readSize(); + var mapType = this.mapType; + var v = new mapType(); + var valueType = this.valueType; + + var readObjectForKey = function(key) + { + is.readObject(function(obj) { v.set(key, obj); }, valueType); + }; + + var keyHelper = this.keyHelper; + for(var i = 0; i < sz; ++i) + { + readObjectForKey(keyHelper.read(is)); + } + return v; + }; + + StreamHelpers.generateDictHelper = function(keyHelper, valueHelper, fixed, valueType, mapType) + { + var helper = new DictionaryHelper(); + if(fixed) + { + StreamHelpers.VSizeContainerOptHelper.call(helper, keyHelper.minWireSize + valueHelper.minWireSize); + } + else + { + StreamHelpers.FSizeOptHelper.call(helper); + } + defineProperty(helper, "mapType", { + get: function(){ return mapType; } + }); + defineProperty(helper, "keyHelper", { + get: function(){ return keyHelper; } + }); + defineProperty(helper, "valueHelper", { + get: function(){ return valueHelper; } + }); + + if(valueHelper == Ice.ObjectHelper) + { + defineProperty(helper, "valueType", { + get: function(){ return valueType; } + }); + helper.read = objectDictionaryHelperRead; + } + + return helper; + }; + + Ice.StreamHelpers = StreamHelpers; + + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/StringUtil.js b/js/src/Ice/StringUtil.js new file mode 100644 index 00000000000..f7866d3d92a --- /dev/null +++ b/js/src/Ice/StringUtil.js @@ -0,0 +1,490 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Debug"); + + var Ice = global.Ice || {}; + + var Debug = Ice.Debug; + + var StringUtil = {}; + + // + // Return the index of the first character in str to + // appear in match, starting from start. Returns -1 if none is + // found. + // + StringUtil.findFirstOf = function(str, match, start) + { + start = start === undefined ? 0 : start; + + var len = str.length; + for(var i = start; i < len; i++) + { + var ch = str.charAt(i); + if(match.indexOf(ch) != -1) + { + return i; + } + } + + return -1; + }; + + // + // Return the index of the first character in str which does + // not appear in match, starting from start. Returns -1 if none is + // found. + // + StringUtil.findFirstNotOf = function(str, match, start) + { + start = start === undefined ? 0 : start; + + var len = str.length; + for(var i = start; i < len; i++) + { + var ch = str.charAt(i); + if(match.indexOf(ch) == -1) + { + return i; + } + } + + return -1; + }; + + // + // Write the byte b as an escape sequence if it isn't a printable ASCII + // character and append the escape sequence to sb. Additional characters + // that should be escaped can be passed in special. If b is any of these + // characters, b is preceded by a backslash in sb. + // + function encodeChar(b, sb, special) + { + switch(b) + { + case 92: // '\\' + { + sb.push("\\\\"); + break; + } + case 39: // '\'' + { + sb.push("\\'"); + break; + } + case 34: // '"' + { + sb.push("\\\""); + break; + } + case 8: // '\b' + { + sb.push("\\b"); + break; + } + case 12: // '\f' + { + sb.push("\\f"); + break; + } + case 10: // '\n' + { + sb.push("\\n"); + break; + } + case 13: // '\r' + { + sb.push("\\r"); + break; + } + case 9: // '\t' + { + sb.push("\\t"); + break; + } + default: + { + if(!(b >= 32 && b <= 126)) + { + sb.push('\\'); + var octal = b.toString(8); + // + // Add leading zeroes so that we avoid problems during + // decoding. For example, consider the encoded string + // \0013 (i.e., a character with value 1 followed by + // the character '3'). If the leading zeroes were omitted, + // the result would be incorrectly interpreted by the + // decoder as a single character with value 11. + // + for(var j = octal.length; j < 3; j++) + { + sb.push('0'); + } + sb.push(octal); + } + else + { + var c = String.fromCharCode(b); + if(special !== null && special.indexOf(c) !== -1) + { + sb.push('\\'); + sb.push(c); + } + else + { + sb.push(c); + } + } + } + } + } + + // + // Add escape sequences (such as "\n", or "\007") to make a string + // readable in ASCII. Any characters that appear in special are + // prefixed with a backlash in the returned string. + // + StringUtil.escapeString = function(s, special) + { + special = special === undefined ? null : special; + + var i, length; + if(special !== null) + { + for(i = 0, length = special.length; i < length; ++i) + { + if(special.charCodeAt(i) < 32 || special.charCodeAt(i) > 126) + { + throw new Error("special characters must be in ASCII range 32-126"); + } + } + } + + var result = [], c; + for(i = 0, length = s.length; i < length; ++i) + { + c = s.charCodeAt(i); + if(c < 128) + { + encodeChar(c, result, special); + } + else if(c > 127 && c < 2048) + { + encodeChar((c >> 6) | 192, result, special); + encodeChar((c & 63) | 128, result, special); + } + else + { + encodeChar((c >> 12) | 224, result, special); + encodeChar(((c >> 6) & 63) | 128, result, special); + encodeChar((c & 63) | 128, result, special); + } + } + + return result.join(""); + }; + + function checkChar(s, pos) + { + var n = s.charCodeAt(pos); + if(!(n >= 32 && n <= 126)) + { + var msg; + if(pos > 0) + { + msg = "character after `" + s.substring(0, pos) + "'"; + } + else + { + msg = "first character"; + } + msg += " is not a printable ASCII character (ordinal " + n + ")"; + throw new Error(msg); + } + return n; + } + + // + // Decode the character or escape sequence starting at start and return it. + // nextStart is set to the index of the first character following the decoded + // character or escape sequence. + // + function decodeChar(s, start, end, nextStart) + { + Debug.assert(start >= 0); + Debug.assert(end <= s.length); + + if(start >= end) + { + throw new Error("EOF while decoding string"); + } + + var c; + + if(s.charAt(start) != '\\') + { + c = checkChar(s, start++); + } + else + { + if(start + 1 == end) + { + throw new Error("trailing backslash"); + } + switch(s.charAt(++start)) + { + case '\\': + case '\'': + case '"': + { + c = s.charCodeAt(start++); + break; + } + case 'b': + { + ++start; + c = "\b".charCodeAt(0); + break; + } + case 'f': + { + ++start; + c = "\f".charCodeAt(0); + break; + } + case 'n': + { + ++start; + c = "\n".charCodeAt(0); + break; + } + case 'r': + { + ++start; + c = "\r".charCodeAt(0); + break; + } + case 't': + { + ++start; + c = "\t".charCodeAt(0); + break; + } + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + { + var octalChars = "01234567"; + var val = 0; + for(var j = 0; j < 3 && start < end; ++j) + { + var ch = s.charAt(start++); + if(octalChars.indexOf(ch) == -1) + { + --start; + break; + } + val = val * 8 + parseInt(ch); + } + if(val > 255) + { + var msg = "octal value \\" + val.toString(8) + " (" + val + ") is out of range"; + throw new Error(msg); + } + c = val; + break; + } + default: + { + c = checkChar(s, start++); + break; + } + } + } + nextStart.value = start; + return c; + } + + // + // Remove escape sequences from s and append the result to sb. + // Return true if successful, false otherwise. + // + function decodeString(s, start, end, arr) + { + var nextStart = { 'value': 0 }, c, c2, c3; + while(start < end) + { + c = decodeChar(s, start, end, nextStart); + start = nextStart.value; + + if(c < 128) + { + arr.push(String.fromCharCode(c)); + } + else if(c > 191 && c < 224) + { + c2 = decodeChar(s, start, end, nextStart); + start = nextStart.value; + arr.push(String.fromCharCode(((c & 31) << 6) | (c2 & 63))); + } + else + { + c2 = decodeChar(s, start, end, nextStart); + start = nextStart.value; + c3 = decodeChar(s, start, end, nextStart); + start = nextStart.value; + arr.push(String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63))); + } + } + } + + // + // Remove escape sequences added by escapeString. Throws Error + // for an invalid input string. + // + StringUtil.unescapeString = function(s, start, end) + { + start = start === undefined ? 0 : start; + end = end === undefined ? s.length : end; + + Debug.assert(start >= 0 && start <= end && end <= s.length); + + var arr = []; + decodeString(s, start, end, arr); + + return arr.join(""); + }; + + // + // Split string helper; returns null for unmatched quotes + // + StringUtil.splitString = function(str, delim) + { + var v = []; + var s = ""; + var pos = 0; + + var quoteChar = null; + while(pos < str.length) + { + if(quoteChar === null && (str.charAt(pos) === '"' || str.charAt(pos) === '\'')) + { + quoteChar = str.charAt(pos++); + continue; // Skip the quote. + } + else if(quoteChar === null && str.charAt(pos) === '\\' && pos + 1 < str.length && + (str.charAt(pos + 1) === '"' || str.charAt(pos + 1) === '\'')) + { + ++pos; // Skip the backslash + } + else if(quoteChar !== null && str.charAt(pos) === '\\' && pos + 1 < str.length && + str.charAt(pos + 1) === quoteChar) + { + ++pos; // Skip the backslash + } + else if(quoteChar !== null && str.charAt(pos) === quoteChar) + { + ++pos; + quoteChar = null; + continue; // Skip the quote. + } + else if(delim.indexOf(str.charAt(pos)) !== -1) + { + if(quoteChar === null) + { + ++pos; + if(s.length > 0) + { + v.push(s); + s = ""; + } + continue; + } + } + + if(pos < str.length) + { + s += str.charAt(pos++); + } + } + + if(s.length > 0) + { + v.push(s); + } + if(quoteChar !== null) + { + return null; // Unmatched quote. + } + + return v; + }; + + // + // If a single or double quotation mark is found at the start position, + // then the position of the matching closing quote is returned. If no + // quotation mark is found at the start position, then 0 is returned. + // If no matching closing quote is found, then -1 is returned. + // + StringUtil.checkQuote = function(s, start) + { + start = start === undefined ? 0 : start; + + var quoteChar = s.charAt(start); + if(quoteChar == '"' || quoteChar == '\'') + { + start++; + var len = s.length; + var pos; + while(start < len && (pos = s.indexOf(quoteChar, start)) != -1) + { + if(s.charAt(pos - 1) != '\\') + { + return pos; + } + start = pos + 1; + } + return -1; // Unmatched quote + } + return 0; // Not quoted + }; + + StringUtil.hashCode = function(s) + { + var hash = 0; + var n = s.length; + + for(var i = 0; i < n; i++) + { + hash = 31 * hash + s.charCodeAt(i); + } + + return hash; + }; + + StringUtil.toInt = function(s) + { + var n = parseInt(s, 10); + if(isNaN(n)) + { + throw new Error("conversion of `" + s + "' to int failed"); + } + return n; + }; + + Ice.StringUtil = StringUtil; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Struct.js b/js/src/Ice/Struct.js new file mode 100644 index 00000000000..99a882089c5 --- /dev/null +++ b/js/src/Ice/Struct.js @@ -0,0 +1,207 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/HashUtil"); + require("Ice/ArrayUtil"); + require("Ice/HashMap"); + require("Ice/StreamHelpers"); + + var Slice = global.Slice || {}; + var Ice = global.Ice || {}; + + var ArrayUtil = Ice.ArrayUtil; + + var eq = function(e1, e2) + { + if(e1 === e2) + { + return true; // If identity compare equals members are equal. + } + else if(e1 === null || e1 === undefined || e2 === null || e2 === undefined) + { + return false; + } + else if(e1.prototype !== e2.prototype) + { + return false; + } + else if(e1 instanceof Ice.HashMap) + { + return e1.equals(e2); + } + else if(typeof e1.equals == "function") + { + return e1.equals(e2); + } + else if(e1 instanceof Array) + { + return ArrayUtil.equals(e1, e2, eq); + } + return false; + }; + + var equals = function(other) + { + if(this === other) + { + return true; + } + + if(other === null || other === undefined) + { + return false; + } + + if(this.prototype !== other.prototype) + { + return false; + } + + var e1, e2; + for(var key in this) + { + + e1 = this[key]; + e2 = other[key]; + if(typeof e1 == "function") + { + continue; // Don't need to compare functions + } + else if(!eq(e1, e2)) + { + return false; + } + } + return true; + }; + + var clone = function() + { + var other = new this.constructor(); + var e; + for(var key in this) + { + e = this[key]; + if(e === undefined || e === null) + { + other[key] = e; + } + else if(typeof e == "function") + { + continue; + } + else if(typeof e.clone == "function") + { + other[key] = e.clone(); + } + else if(e instanceof Array) + { + other[key] = ArrayUtil.clone(e); + } + else + { + other[key] = e; + } + } + return other; + }; + + var memberHashCode = function(h, e) + { + if(typeof e.hashCode == "function") + { + return Ice.HashUtil.addHashable(h, e); + } + else if(e instanceof Array) + { + return Ice.HashUtil.addArray(h, e, memberHashCode); + } + else + { + var t = typeof(e); + if(e instanceof String || t == "string") + { + return Ice.HashUtil.addString(h, e); + } + else if(e instanceof Number || t == "number") + { + return Ice.HashUtil.addNumber(h, e); + } + else if(e instanceof Boolean || t == "boolean") + { + return Ice.HashUtil.addBoolean(h, e); + } + } + }; + + var hashCode = function() + { + var __h = 5381; + var e; + for(var key in this) + { + e = this[key]; + if(e === undefined || e === null || typeof e == "function") + { + continue; + } + __h = memberHashCode(__h, e); + } + return __h; + }; + + Slice.defineStruct = function(constructor, legalKeyType, writeImpl, readImpl, minWireSize, fixed) + { + var obj = constructor; + + obj.prototype.clone = clone; + + obj.prototype.equals = equals; + + // + // Only generate hashCode if this structure type is a legal dictionary key type. + // + if(legalKeyType) + { + obj.prototype.hashCode = hashCode; + } + + if(readImpl && writeImpl) + { + obj.prototype.__write = writeImpl; + obj.prototype.__read = readImpl; + obj.write = function(os, v) + { + v.__write(os); + }; + obj.read = function(is) + { + var v = new this(); + v.__read(is); + return v; + }; + Object.defineProperty(obj, "minWireSize", { + get: function() { return minWireSize; } + }); + if(fixed) + { + Ice.StreamHelpers.VSizeOptHelper.call(obj); + } + else + { + Ice.StreamHelpers.FSizeOptHelper.call(obj); + } + } + return obj; + }; + + global.Slice = Slice; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/TcpEndpointFactory.js b/js/src/Ice/TcpEndpointFactory.js new file mode 100644 index 00000000000..d459685efb5 --- /dev/null +++ b/js/src/Ice/TcpEndpointFactory.js @@ -0,0 +1,49 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/TcpEndpointI"); + require("Ice/Endpoint"); + + var Ice = global.Ice || {}; + + var TcpEndpointI = Ice.TcpEndpointI; + var TCPEndpointType = Ice.TCPEndpointType; + + var TcpEndpointFactory = Ice.Class({ + __init__: function(instance) + { + this._instance = instance; + }, + type: function() + { + return TCPEndpointType; + }, + protocol: function() + { + return "tcp"; + }, + create: function(str, oaEndpoint) + { + return TcpEndpointI.fromString(this._instance, str, oaEndpoint); + }, + read: function(s) + { + return TcpEndpointI.fromStream(s); + }, + destroy: function() + { + this._instance = null; + } + }); + + Ice.TcpEndpointFactory = TcpEndpointFactory; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/TcpEndpointI.js b/js/src/Ice/TcpEndpointI.js new file mode 100644 index 00000000000..97851850877 --- /dev/null +++ b/js/src/Ice/TcpEndpointI.js @@ -0,0 +1,496 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Address"); + require("Ice/HashUtil"); + require("Ice/StringUtil"); + require("Ice/TcpTransceiver"); + require("Ice/Endpoint"); + require("Ice/LocalException"); + + var Ice = global.Ice || {}; + + var Address = Ice.Address; + var HashUtil = Ice.HashUtil; + var StringUtil = Ice.StringUtil; + var TcpTransceiver = Ice.TcpTransceiver; + + var Class = Ice.Class; + var TcpEndpointI = Class(Ice.Endpoint, { + __init__: function(instance, ho, po, ti, conId, co) + { + this._instance = instance; + this._host = ho; + this._port = po; + this._timeout = ti; + this._connectionId = conId; + this._compress = co; + this.calcHashValue(); + }, + // + // Convert the endpoint to its string form + // + toString: function() + { + // + // WARNING: Certain features, such as proxy validation in Glacier2, + // depend on the format of proxy strings. Changes to toString() and + // methods called to generate parts of the reference string could break + // these features. Please review for all features that depend on the + // format of proxyToString() before changing this and related code. + // + var s = "tcp"; + + if(this._host !== null && this._host.length > 0) + { + s += " -h "; + var addQuote = this._host.indexOf(':') != -1; + if(addQuote) + { + s += "\""; + } + s += this._host; + if(addQuote) + { + s += "\""; + } + } + + s += " -p " + this._port; + + if(this._timeout != -1) + { + s += " -t " + this._timeout; + } + if(this._compress) + { + s += " -z"; + } + return s; + }, + // + // Return the endpoint information. + // + getInfo: function() + { + return new TCPEndpointInfoI(this._timeout, this._compress, this._host, this._port); + }, + // + // Marshal the endpoint + // + streamWrite: function(s) + { + s.writeShort(Ice.TCPEndpointType); + s.startWriteEncaps(); + s.writeString(this._host); + s.writeInt(this._port); + s.writeInt(this._timeout); + s.writeBool(this._compress); + s.endWriteEncaps(); + }, + // + // Return the endpoint type + // + type: function() + { + return Ice.TCPEndpointType; + }, + // + // Return the timeout for the endpoint in milliseconds. 0 means + // non-blocking, -1 means no timeout. + // + timeout: function() + { + return this._timeout; + }, + // + // Return a new endpoint with a different timeout value, provided + // that timeouts are supported by the endpoint. Otherwise the same + // endpoint is returned. + // + changeTimeout: function(timeout) + { + if(timeout === this._timeout) + { + return this; + } + else + { + return new TcpEndpointI(this._instance, this._host, this._port, timeout, this._connectionId, + this._compress); + } + }, + // + // Return a new endpoint with a different connection id. + // + changeConnectionId: function(connectionId) + { + if(connectionId === this._connectionId) + { + return this; + } + else + { + return new TcpEndpointI(this._instance, this._host, this._port, this._timeout, connectionId, + this._compress); + } + }, + // + // Return true if the endpoints support bzip2 compress, or false + // otherwise. + // + compress: function() + { + return this._compress; + }, + // + // Return a new endpoint with a different compression value, + // provided that compression is supported by the + // endpoint. Otherwise the same endpoint is returned. + // + changeCompress: function(compress) + { + if(compress === this._compress) + { + return this; + } + else + { + return new TcpEndpointI(this._instance, this._host, this._port, this._timeout, this._connectionId, + compress); + } + }, + // + // Return true if the endpoint is datagram-based. + // + datagram: function() + { + return false; + }, + // + // Return true if the endpoint is secure. + // + secure: function() + { + return false; + }, + // + // Return a server side transceiver for this endpoint, or null if a + // transceiver can only be created by an acceptor. In case a + // transceiver is created, this operation also returns a new + // "effective" endpoint, which might differ from this endpoint, + // for example, if a dynamic port number is assigned. + // + transceiver: function(endpoint) + { + endpoint.value = this; + return null; + }, + connect: function() + { + if(this._instance.traceLevels().network >= 2) + { + var msg = "trying to establish tcp connection to " + this._host + ":" + this._port; + this._instance.initializationData().logger.trace(this._instance.traceLevels().networkCat, msg); + } + + return TcpTransceiver.createOutgoing(this._instance, new Address(this._host, this._port)); + }, + hashCode: function() + { + return this._hashCode; + }, + // + // Compare endpoints for sorting purposes + // + equals: function(p) + { + if(!(p instanceof TcpEndpointI)) + { + return false; + } + + if(this === p) + { + return true; + } + + if(this._host !== p._host) + { + return false; + } + + if(this._port !== p._port) + { + return false; + } + + if(this._timeout !== p._timeout) + { + return false; + } + + if(this._connectionId !== p._connectionId) + { + return false; + } + + if(this._compress !== p._compress) + { + return false; + } + + return true; + }, + compareTo: function(p) + { + if(this === p) + { + return 0; + } + + if(p === null) + { + return 1; + } + + if(!(p instanceof TcpEndpointI)) + { + return this.type() < p.type() ? -1 : 1; + } + + if(this._port < p._port) + { + return -1; + } + else if(p._port < this._port) + { + return 1; + } + + if(this._timeout < p._timeout) + { + return -1; + } + else if(p._timeout < this._timeout) + { + return 1; + } + + if(this._connectionId != p._connectionId) + { + return this._connectionId < p._connectionId ? -1 : 1; + } + + if(!this._compress && p._compress) + { + return -1; + } + else if(!p._compress && this._compress) + { + return 1; + } + + if(this._host == p._host) + { + return 0; + } + else + { + return this._host < p._host ? -1 : 1; + } + }, + calcHashValue: function() + { + var h = 5381; + h = HashUtil.addNumber(h, Ice.TCPEndpointType); + h = HashUtil.addString(h, this._host); + h = HashUtil.addNumber(h, this._port); + h = HashUtil.addNumber(h, this._timeout); + h = HashUtil.addString(h, this._connectionId); + h = HashUtil.addBoolean(h, this._compress); + this._hashCode = h; + } + }); + + TcpEndpointI.fromString = function(instance, str, oaEndpoint) + { + var host = null; + var port = 0; + var timeout = -1; + var compress = false; + + var arr = str.split(/[ \t\n\r]+/); + + var i = 0; + while(i < arr.length) + { + if(arr[i].length === 0) + { + i++; + continue; + } + + var option = arr[i++]; + if(option.length != 2 && option.charAt(0) != '-') + { + throw new Ice.EndpointParseException("expected an endpoint option but found `" + option + + "' in endpoint `tcp " + str + "'"); + } + + var argument = null; + if(i < arr.length && arr[i].charAt(0) != '-') + { + argument = arr[i++]; + if(argument.charAt(0) == '\"' && argument.charAt(argument.length - 1) == '\"') + { + argument = argument.substring(1, argument.length - 1); + } + } + + switch(option.charAt(1)) + { + case 'h': + { + if(argument === null) + { + throw new Ice.EndpointParseException( + "no argument provided for -h option in endpoint `tcp " + str + "'"); + } + + host = argument; + break; + } + + case 'p': + { + if(argument === null) + { + throw new Ice.EndpointParseException( + "no argument provided for -p option in endpoint `tcp " + str + "'"); + } + + try + { + port = StringUtil.toInt(argument); + } + catch(ex) + { + throw new Ice.EndpointParseException("invalid port value `" + argument + + "' in endpoint `tcp " + str + "'"); + } + + if(port < 0 || port > 65535) + { + throw new Ice.EndpointParseException("port value `" + argument + + "' out of range in endpoint `tcp " + str + "'"); + } + + break; + } + + case 't': + { + if(argument === null) + { + throw new Ice.EndpointParseException( + "no argument provided for -t option in endpoint `tcp " + str + "'"); + } + + try + { + timeout = StringUtil.toInt(argument); + } + catch(ex) + { + throw new Ice.EndpointParseException( + "invalid timeout value `" + argument + "' in endpoint `tcp " + str + "'"); + } + + break; + } + + case 'z': + { + if(argument !== null) + { + throw new Ice.EndpointParseException("unexpected argument `" + argument + + "' provided for -z option in `tcp " + str + "'"); + } + + compress = true; + break; + } + + default: + { + throw new Ice.EndpointParseException("unknown option `" + option + "' in `tcp " + str + "'"); + } + } + } + + if(host === null) + { + host = instance.defaultsAndOverrides().defaultHost; + } + else if(host == "*") + { + if(oaEndpoint) + { + host = null; + } + else + { + throw new Ice.EndpointParseException("`-h *' not valid for proxy endpoint `tcp " + str + "'"); + } + } + + if(host === null) + { + host = ""; + } + + return new TcpEndpointI(instance, host, port, timeout, "", compress); + }; + + TcpEndpointI.fromStream = function(s) + { + s.startReadEncaps(); + var host = s.readString(); + var port = s.readInt(); + var timeout = s.readInt(); + var compress = s.readBool(); + s.endReadEncaps(); + return new TcpEndpointI(s.instance, host, port, timeout, "", compress); + }; + + Ice.TcpEndpointI = TcpEndpointI; + global.Ice = Ice; + + var TCPEndpointInfoI = Class(Ice.TCPEndpointInfo, { + __init__: function(timeout, compress, host, port) + { + Ice.TCPEndpointInfo.call(this, timeout, compress, host, port); + }, + type: function() + { + return Ice.TCPEndpointType; + }, + datagram: function() + { + return false; + }, + secure: function() + { + return false; + } + }); +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/TcpTransceiver.js b/js/src/Ice/TcpTransceiver.js new file mode 100644 index 00000000000..a6a4615297c --- /dev/null +++ b/js/src/Ice/TcpTransceiver.js @@ -0,0 +1,458 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + var net = require("net"); + + require("Ice/Class"); + require("Ice/Debug"); + require("Ice/ExUtil"); + require("Ice/SocketOperation"); + require("Ice/Connection"); + require("Ice/Exception"); + require("Ice/LocalException"); + + var Ice = global.Ice || {}; + + var Debug = Ice.Debug; + var ExUtil = Ice.ExUtil; + var Network = Ice.Network; + var SocketOperation = Ice.SocketOperation; + var LocalException = Ice.LocalException; + var SocketException = Ice.SocketException; + + var StateNeedConnect = 0; + var StateConnectPending = 1; + var StateProxyConnectRequest = 2; + var StateProxyConnectRequestPending = 3; + var StateConnected = 4; + var StateClosed = 5; + + var TcpTransceiver = Ice.Class({ + __init__: function(instance) + { + this._traceLevels = instance.traceLevels(); + this._logger = instance.initializationData().logger; + this._readBuffers = []; + this._readPosition = 0; + }, + setCallbacks: function(connectedCallback, bytesAvailableCallback, bytesWrittenCallback) + { + this._connectedCallback = connectedCallback; + this._bytesAvailableCallback = bytesAvailableCallback; + this._bytesWrittenCallback = bytesWrittenCallback; + + var self = this; + this._fd.on("connect", function() { self.socketConnected(); }); + this._fd.on("close", function(err) { self.socketClosed(err); }); + this._fd.on("error", function(err) { self.socketError(err); }); + this._fd.on("data", function(buf) { self.socketBytesAvailable(buf); }); + }, + // + // Returns SocketOperation.None when initialization is complete. + // + initialize: function(readBuffer, writeBuffer) + { + try + { + if(this._exception) + { + throw this._exception; + } + + if(this._state === StateNeedConnect) + { + this._state = StateConnectPending; + this._fd.connect(this._addr.port, this._addr.host); + return SocketOperation.Connect; // Waiting for connect to complete. + } + else if(this._state === StateConnectPending) + { + // + // Socket is connected. + // + this._desc = fdToString(this._fd, this._proxy, this._addr); + this._state = StateConnected; + } + else if(this._state === StateProxyConnectRequest) + { + // + // Write completed. + // + this._proxy.endWriteConnectRequest(writeBuffer); + this._state = StateProxyConnectRequestPending; // Wait for proxy response + return SocketOperation.Read; + } + else if(this._state === StateProxyConnectRequestPending) + { + // + // Read completed. + // + this._proxy.endReadConnectRequestResponse(readBuffer); + this._state = StateConnected; + } + } + catch(err) + { + if(!this._exception) + { + this._exception = translateError(this._state, err); + } + + if(this._traceLevels.network >= 2) + { + var s = []; + s.push("failed to establish tcp connection\n"); + s.push(fdToString(this._fd, this._proxy, this._addr.host, this._addr.port)); + this._logger.trace(this._traceLevels.networkCat, s.join("")); + } + + throw this._exception; + } + + Debug.assert(this._state === StateConnected); + if(this._traceLevels.network >= 1) + { + var s = "tcp connection established\n" + this._desc; + this._logger.trace(this._traceLevels.networkCat, s); + } + + return SocketOperation.None; + }, + register: function() + { + this._registered = true; + this._fd.resume(); + if(this._exception) + { + this._bytesAvailableCallback(); + } + }, + unregister: function() + { + this._registered = false; + this._fd.pause(); + }, + close: function() + { + if(this._state > StateConnectPending && this._traceLevels.network >= 1) + { + this._logger.trace(this._traceLevels.networkCat, "closing " + this.type() + " connection\n" + + this._desc); + } + + Debug.assert(this._fd !== null); + try + { + this._fd.destroy(); + } + catch(ex) + { + throw translateError(this._state, ex); + } + finally + { + this._fd = null; + } + }, + // + // Returns true if all of the data was flushed to the kernel buffer. + // + write: function(byteBuffer) + { + if(this._exception) + { + throw this._exception; + } + + var remaining = byteBuffer.remaining; + Debug.assert(remaining > 0); + + // + // Create a slice of the source buffer representing the remaining data to be written. + // + var slice = byteBuffer.b.slice(byteBuffer.position, byteBuffer.position + remaining); + + // + // The socket will accept all of the data. + // + byteBuffer.position = byteBuffer.position + remaining; + + var self = this; + + var sync = true; + sync = this._fd.write(slice, null, function() { + if(self._traceLevels.network >= 3) + { + var msg = "sent " + remaining + " bytes via " + self.type() + "\n" + self._desc; + self._logger.trace(self._traceLevels.networkCat, msg); + } + if(!sync) + { + self._bytesWrittenCallback(); + } + }); + return sync; + }, + read: function(byteBuffer, moreData) + { + if(this._exception) + { + throw this._exception; + } + + moreData.value = false; + + if(this._readBuffers.length === 0) + { + return false; // No data available. + } + + var avail = this._readBuffers[0].length - this._readPosition; + Debug.assert(avail > 0); + var remaining = byteBuffer.remaining; + + while(byteBuffer.remaining > 0) + { + if(avail > byteBuffer.remaining) + { + avail = byteBuffer.remaining; + } + + this._readBuffers[0].copy(byteBuffer.b, byteBuffer.position, this._readPosition, + this._readPosition + avail); + + byteBuffer.position += avail; + this._readPosition += avail; + if(this._readPosition === this._readBuffers[0].length) + { + // + // We've exhausted the current read buffer. + // + this._readPosition = 0; + this._readBuffers.shift(); + if(this._readBuffers.length === 0) + { + break; // No more data - we're done. + } + else + { + avail = this._readBuffers[0].length; + } + } + } + + var n = remaining - byteBuffer.remaining; + if(n > 0 && this._traceLevels.network >= 3) + { + var msg = "received " + n + " of " + remaining + " bytes via " + this.type() + "\n" + this._desc; + this._logger.trace(this._traceLevels.networkCat, msg); + } + + moreData.value = this._readBuffers.length > 0; + + return byteBuffer.remaining === 0; + }, + type: function() + { + return "tcp"; + }, + getInfo: function() + { + Debug.assert(this._fd !== null); + var info = this.createInfo(); + info.localAddress = this._fd.localAddress; + info.localPort = this._fd.localPort; + info.remoteAddress = this._fd.remoteAddress; + info.remotePort = this._fd.remotePort; + return info; + }, + createInfo: function() + { + return new Ice.TCPConnectionInfo(); + }, + checkSendSize: function(stream, messageSizeMax) + { + if(stream.size > messageSizeMax) + { + ExUtil.throwMemoryLimitException(stream.size, messageSizeMax); + } + }, + toString: function() + { + return this._desc; + }, + socketConnected: function() + { + Debug.assert(this._connectedCallback !== null); + this._connectedCallback(); + }, + socketBytesAvailable: function(buf) + { + Debug.assert(this._bytesAvailableCallback !== null); + + // + // TODO: Should we set a limit on how much data we can read? + // We can call _fd.pause() to temporarily stop reading. + // + if(buf.length > 0) + { + this._readBuffers.push(buf); + this._bytesAvailableCallback(); + } + }, + socketClosed: function(err) + { + // + // Don't call the closed callback if an error occurred; the error callback + // will be called. + // + if(!err) + { + this.socketError(null); + } + }, + socketError: function(err) + { + this._exception = translateError(this._state, err) + if(this._state < StateConnected) + { + this._connectedCallback(); + } + else if(this._registered) + { + this._bytesAvailableCallback(); + } + } + }); + + function fdToString(fd, targetAddr) + { + if(fd === null) + { + return "<closed>"; + } + + return addressesToString(fd.localAddress, fd.localPort, fd.remoteAddress, fd.remotePort, targetAddr); + } + + function translateError(state, err) + { + if(!err) + { + return new Ice.ConnectionLostException(); + } + else if(state < StateConnected) + { + if(connectionRefused(err.code)) + { + return new Ice.ConnectionRefusedException(err.code, err); + } + else if(connectionFailed(err.code)) + { + return new Ice.ConnectFailedException(err.code, err); + } + } + else if(connectionLost(err.code)) + { + return new Ice.ConnectionLostException(err.code, err); + } + return new Ice.SocketException(err.code, err); + } + + function addressesToString(localHost, localPort, remoteHost, remotePort, targetAddr) + { + remoteHost = remoteHost === undefined ? null : remoteHost; + targetAddr = targetAddr === undefined ? null : targetAddr; + + var s = []; + s.push("local address = "); + s.push(localHost + ":" + localPort); + + if(remoteHost === null && targetAddr !== null) + { + remoteHost = targetAddr.host; + remotePort = targetAddr.port; + } + + if(remoteHost === null) + { + s.push("\nremote address = <not connected>"); + } + else + { + s.push("\nremote address = "); + s.push(remoteHost + ":" + remotePort); + } + + return s.join(""); + }; + + TcpTransceiver.createOutgoing = function(instance, addr) + { + var transceiver = new TcpTransceiver(instance); + + transceiver._fd = new net.Socket(); + transceiver._addr = addr; + transceiver._desc = "remote address: " + addr.host + ":" + addr.port + " <not connected>"; + transceiver._state = StateNeedConnect; + transceiver._registered = false; + transceiver._exception = null; + + return transceiver; + }; + + TcpTransceiver.createIncoming = function(instance, fd) + { + var transceiver = new TcpTransceiver(instance); + + transceiver._fd = fd; + transceiver._addr = null; + transceiver._desc = fdToString(fd); + transceiver._state = StateConnected; + transceiver._registered = false; + transceiver._exception = null; + + return transceiver; + }; + + + var ECONNABORTED = "ECONNABORTED"; + var ECONNREFUSED = "ECONNREFUSED"; + var ECONNRESET = "ECONNRESET" + var EHOSTUNREACH = "EHOSTUNREACH"; + var ENETUNREACH = "ENETUNREACH"; + var ENOTCONN = "ENOTCONN"; + var EPIPE = "EPIPE"; + var ESHUTDOWN = "ESHUTDOWN" + var ETIMEDOUT = "ETIMEDOUT"; + + function connectionRefused(err) + { + return err == ECONNREFUSED; + } + + function connectionFailed(err) + { + return err == ECONNREFUSED || err == ETIMEDOUT || + err == ENETUNREACH || err == EHOSTUNREACH || + err == ECONNRESET || err == ESHUTDOWN || + err == ECONNABORTED; + } + + function connectionLost(err) + { + return err == ECONNRESET || err == ENOTCONN || + err == ESHUTDOWN || err == ECONNABORTED || + err == EPIPE; + } + + Ice.TcpTransceiver = TcpTransceiver; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/TimeUtil.js b/js/src/Ice/TimeUtil.js new file mode 100644 index 00000000000..ad152cd7f09 --- /dev/null +++ b/js/src/Ice/TimeUtil.js @@ -0,0 +1,19 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + var Ice = global.Ice || {}; + var TimeUtil = {}; + TimeUtil.now = function() + { + return new Date().getTime(); + }; + Ice.TimeUtil = TimeUtil; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/Timer.js b/js/src/Ice/Timer.js new file mode 100644 index 00000000000..0c489726d98 --- /dev/null +++ b/js/src/Ice/Timer.js @@ -0,0 +1,123 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/HashMap"); + require("Ice/LocalException"); + require("Ice/Class"); + + var Ice = global.Ice || {}; + + var HashMap = Ice.HashMap; + var CommunicatorDestroyedException = Ice.CommunicatorDestroyedException; + + var Timer = Ice.Class({ + __init__: function(instance) + { + this._instance = instance; + this._destroyed = false; + this._tokenId = 0; + this._tokens = new HashMap(); + }, + destroy: function() + { + var self = this; + this._tokens.forEach(function(key, value){ + self.cancel(key); + }); + this._destroyed = true; + this._tokens.clear(); + }, + schedule: function(callback, delay) + { + if(this._destroyed) + { + throw new CommunicatorDestroyedException(); + } + + var token = this._tokenId++; + var self = this; + + var id = setTimeout(function() { self.handleTimeout(token); }, delay); + this._tokens.set(token, { callback: callback, id: id, isInterval: false }); + + return token; + }, + scheduleRepeated: function(callback, period) + { + if(this._destroyed) + { + throw new CommunicatorDestroyedException(); + } + + var token = this._tokenId++; + var self = this; + + var id = setInterval(function() { self.handleInterval(token); }, period); + this._tokens.set(token, { callback: callback, id: id, isInterval: true }); + + return token; + }, + cancel: function(id) + { + if(this._destroyed) + { + return false; + } + + var token = this._tokens.get(id); + if(token === undefined) + { + return false; + } + + this._tokens.delete(id); + if(token.isInterval) + { + clearInterval(token.id); + } + else + { + clearTimeout(token.id); + } + + return true; + }, + handleTimeout: function(id) + { + if(this._destroyed) + { + return; + } + + var token = this._tokens.get(id); + if(token !== undefined) + { + this._tokens.delete(id); + token.callback(); + } + }, + handleInterval: function(id) + { + if(this._destroyed) + { + return; + } + + var token = this._tokens.get(id); + if(token !== undefined) + { + token.callback(); + } + } + }); + + Ice.Timer = Timer; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/TraceLevels.js b/js/src/Ice/TraceLevels.js new file mode 100644 index 00000000000..512813d8b18 --- /dev/null +++ b/js/src/Ice/TraceLevels.js @@ -0,0 +1,66 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + var Ice = global.Ice || {}; + + var TraceLevels = function(properties) + { + var networkCat = "Network"; + var protocolCat = "Protocol"; + var retryCat = "Retry"; + var locationCat = "Locator"; + var slicingCat = "Slicing"; + + var keyBase = "Ice.Trace."; + + var network = properties.getPropertyAsInt(keyBase + networkCat); + var protocol = properties.getPropertyAsInt(keyBase + protocolCat); + var retry = properties.getPropertyAsInt(keyBase + retryCat); + var location = properties.getPropertyAsInt(keyBase + locationCat); + var slicing = properties.getPropertyAsInt(keyBase + slicingCat); + properties.getPropertyAsInt(keyBase + "ThreadPool"); // Avoid an "unused property" warning. + + return Object.create(null, { + 'network': { + get: function() { return network; } + }, + 'networkCat': { + get: function() { return networkCat; } + }, + 'protocol': { + get: function() { return protocol; } + }, + 'protocolCat': { + get: function() { return protocolCat; } + }, + 'retry': { + get: function() { return retry; } + }, + 'retryCat': { + get: function() { return retryCat; } + }, + 'location': { + get: function() { return location; } + }, + 'locationCat': { + get: function() { return locationCat; } + }, + 'slicing': { + get: function() { return slicing; } + }, + 'slicingCat': { + get: function() { return slicingCat; } + } + }); + }; + + Ice.TraceLevels = TraceLevels; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/TraceUtil.js b/js/src/Ice/TraceUtil.js new file mode 100644 index 00000000000..2e119ca6dcf --- /dev/null +++ b/js/src/Ice/TraceUtil.js @@ -0,0 +1,474 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Debug"); + require("Ice/HashMap"); + require("Ice/Protocol"); + require("Ice/StringUtil"); + require("Ice/Current"); + require("Ice/Identity"); + + var Ice = global.Ice || {}; + + // + // Local aliases. + // + var Debug = Ice.Debug; + var HashMap = Ice.HashMap; + var Protocol = Ice.Protocol; + var StringUtil = Ice.StringUtil; + var OperationMode = Ice.OperationMode; + var Identity = Ice.Identity; + + var TraceUtil = {}; + + TraceUtil.traceSend = function(stream, logger, traceLevels) + { + if(traceLevels.protocol >= 1) + { + var p = stream.pos; + stream.pos = 0; + + var s = []; + var type = printMessage(s, stream); + + logger.trace(traceLevels.protocolCat, "sending " + getMessageTypeAsString(type) + " " + s.join("")); + + stream.pos = p; + } + }; + + TraceUtil.traceRecv = function(stream, logger, traceLevels) + { + if(traceLevels.protocol >= 1) + { + var p = stream.pos; + stream.pos = 0; + + var s = []; + var type = printMessage(s, stream); + + logger.trace(traceLevels.protocolCat, "received " + getMessageTypeAsString(type) + " " + s.join("")); + + stream.pos = p; + } + }; + + TraceUtil.trace = function(heading, stream, logger, traceLevels) + { + if(traceLevels.protocol >= 1) + { + var p = stream.pos; + stream.pos = 0; + + var s = []; + s.push(heading); + printMessage(s, stream); + + logger.trace(traceLevels.protocolCat, s.join("")); + stream.pos = p; + } + }; + + var slicingIds = new HashMap(); + + function traceSlicing(kind, typeId, slicingCat, logger) + { + if(!slicingIds.has(typeId)) + { + var s = "unknown " + kind + " type `" + typeId + "'"; + logger.trace(slicingCat, s); + slicingIds.set(typeId, 1); + } + } + + TraceUtil.dumpStream = function(stream) + { + var pos = stream.pos; + stream.pos = 0; + + var data = stream.readBlob(stream.size()); + TraceUtil.dumpOctets(data); + + stream.pos = pos; + }; + + TraceUtil.dumpOctets = function(data) + { + var inc = 8; + var buf = []; + + for(var i = 0; i < data.length; i += inc) + { + var j; + for(j = i; j - i < inc; j++) + { + if(j < data.length) + { + var n = data[j]; + if(n < 0) + { + n += 256; + } + var s; + if(n < 10) + { + s = " " + n; + } + else if(n < 100) + { + s = " " + n; + } + else + { + s = "" + n; + } + buf.push(s + " "); + } + else + { + buf.push(" "); + } + } + + buf.push('"'); + + for(j = i; j < data.length && j - i < inc; j++) + { + if(data[j] >= 32 && data[j] < 127) + { + buf.push(String.fromCharCode(data[j])); + } + else + { + buf.push('.'); + } + } + + buf.push("\"\n"); + } + + console.log(buf.join("")); + }; + + Ice.TraceUtil = TraceUtil; + global.Ice = Ice; + + function printIdentityFacetOperation(s, stream) + { + var identity = new Identity(); + identity.__read(stream); + s.push("\nidentity = " + stream.instance.identityToString(identity)); + + var facet = Ice.StringSeqHelper.read(stream); + s.push("\nfacet = "); + if(facet.length > 0) + { + s.push(StringUtil.escapeString(facet[0], "")); + } + + var operation = stream.readString(); + s.push("\noperation = " + operation); + } + + function printRequest(s, stream) + { + var requestId = stream.readInt(); + s.push("\nrequest id = " + requestId); + if(requestId === 0) + { + s.push(" (oneway)"); + } + + printRequestHeader(s, stream); + } + + function printBatchRequest(s, stream) + { + var batchRequestNum = stream.readInt(); + s.push("\nnumber of requests = " + batchRequestNum); + + for(var i = 0; i < batchRequestNum; ++i) + { + s.push("\nrequest #" + i + ':'); + printRequestHeader(s, stream); + } + } + + function printReply(s, stream) + { + var requestId = stream.readInt(); + s.push("\nrequest id = " + requestId); + + var replyStatus = stream.readByte(); + s.push("\nreply status = " + replyStatus + ' '); + + switch(replyStatus) + { + case Protocol.replyOK: + { + s.push("(ok)"); + break; + } + + case Protocol.replyUserException: + { + s.push("(user exception)"); + break; + } + + case Protocol.replyObjectNotExist: + case Protocol.replyFacetNotExist: + case Protocol.replyOperationNotExist: + { + switch(replyStatus) + { + case Protocol.replyObjectNotExist: + { + s.push("(object not exist)"); + break; + } + + case Protocol.replyFacetNotExist: + { + s.push("(facet not exist)"); + break; + } + + case Protocol.replyOperationNotExist: + { + s.push("(operation not exist)"); + break; + } + + default: + { + Debug.assert(false); + break; + } + } + + printIdentityFacetOperation(s, stream); + break; + } + + case Protocol.replyUnknownException: + case Protocol.replyUnknownLocalException: + case Protocol.replyUnknownUserException: + { + switch(replyStatus) + { + case Protocol.replyUnknownException: + { + s.push("(unknown exception)"); + break; + } + + case Protocol.replyUnknownLocalException: + { + s.push("(unknown local exception)"); + break; + } + + case Protocol.replyUnknownUserException: + { + s.push("(unknown user exception)"); + break; + } + + default: + { + Debug.assert(false); + break; + } + } + + var unknown = stream.readString(); + s.push("\nunknown = " + unknown); + break; + } + + default: + { + s.push("(unknown)"); + break; + } + } + } + + function printRequestHeader(s, stream) + { + printIdentityFacetOperation(s, stream); + + var mode = stream.readByte(); + s.push("\nmode = " + mode + ' '); + switch(OperationMode.valueOf(mode)) + { + case OperationMode.Normal: + { + s.push("(normal)"); + break; + } + + case OperationMode.Nonmutating: + { + s.push("(nonmutating)"); + break; + } + + case OperationMode.Idempotent: + { + s.push("(idempotent)"); + break; + } + + default: + { + s.push("(unknown)"); + break; + } + } + + var sz = stream.readSize(); + s.push("\ncontext = "); + while(sz-- > 0) + { + var key = stream.readString(); + var value = stream.readString(); + s.push(key + '/'+ value); + if(sz > 0) + { + s.push(", "); + } + } + + var ver = stream.skipEncaps(); + if(!ver.equals(Protocol.Encoding_1_0)) + { + s.push("\nencoding = "); + s.push(Ice.encodingVersionToString(ver)); + } + } + + function printHeader(s, stream) + { + stream.readByte(); // Don't bother printing the magic number + stream.readByte(); + stream.readByte(); + stream.readByte(); + + // var pMajor = stream.readByte(); + // var pMinor = stream.readByte(); + // s.push("\nprotocol version = " + pMajor + "." + pMinor); + stream.readByte(); // major + stream.readByte(); // minor + + // var eMajor = stream.readByte(); + // var eMinor = stream.readByte(); + // s.push("\nencoding version = " + eMajor + "." + eMinor); + stream.readByte(); // major + stream.readByte(); // minor + + var type = stream.readByte(); + + s.push("\nmessage type = " + type + " (" + getMessageTypeAsString(type) + ')'); + var compress = stream.readByte(); + s.push("\ncompression status = " + compress + ' '); + switch(compress) + { + case 0: + { + s.push("(not compressed; do not compress response, if any)"); + break; + } + + case 1: + { + s.push("(not compressed; compress response, if any)"); + break; + } + + case 2: + { + s.push("(compressed; compress response, if any)"); + break; + } + + default: + { + s.push("(unknown)"); + break; + } + } + + var size = stream.readInt(); + s.push("\nmessage size = " + size); + return type; + } + + function printMessage(s, stream) + { + var type = printHeader(s, stream); + + switch(type) + { + case Protocol.closeConnectionMsg: + case Protocol.validateConnectionMsg: + { + // We're done. + break; + } + + case Protocol.requestMsg: + { + printRequest(s, stream); + break; + } + + case Protocol.requestBatchMsg: + { + printBatchRequest(s, stream); + break; + } + + case Protocol.replyMsg: + { + printReply(s, stream); + break; + } + + default: + { + break; + } + } + + return type; + } + + function getMessageTypeAsString(type) + { + switch(type) + { + case Protocol.requestMsg: + return "request"; + case Protocol.requestBatchMsg: + return "batch request"; + case Protocol.replyMsg: + return "reply"; + case Protocol.closeConnectionMsg: + return "close connection"; + case Protocol.validateConnectionMsg: + return "validate connection"; + default: + return "unknown"; + } + } +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/UUID.js b/js/src/Ice/UUID.js new file mode 100644 index 00000000000..11928fcb1da --- /dev/null +++ b/js/src/Ice/UUID.js @@ -0,0 +1,30 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + var Ice = global.Ice || {}; + + var UUID = {}; + + UUID.generateUUID = function() + { + var d = new Date().getTime(); + var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) { + var r = (d + Math.random() * 16) % 16 | 0; + d = Math.floor(d / 16); + return (c == 'x' ? r : (r & 0x7 | 0x8)).toString(16); + }); + return uuid; + }; + + Ice.UUID = UUID; + Ice.generateUUID = UUID.generateUUID; + + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/UnknownSlicedObject.js b/js/src/Ice/UnknownSlicedObject.js new file mode 100644 index 00000000000..70ef7146f53 --- /dev/null +++ b/js/src/Ice/UnknownSlicedObject.js @@ -0,0 +1,80 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Object"); + require("Ice/Class"); + + var Ice = global.Ice || {}; + + var SliceInfo = function() + { + /** + * The Slice type ID for this slice. + **/ + this.typeId = ""; + + /** + * The Slice compact type ID for this slice. + **/ + this.compactId = -1; + + /** + * The encoded bytes for this slice, including the leading size integer. + **/ + this.bytes = []; + + /** + * The Ice objects referenced by this slice. + **/ + this.objects = []; + + /** + * Whether or not the slice contains optional members. + **/ + this.hasOptionalMembers = false; + + /** + * Whether or not this is the last slice. + **/ + this.isLastSlice = false; + }; + + var SlicedData = function(slices) + { + this.slices = slices; + }; + + var UnknownSlicedObject = Ice.Class(Ice.Object, + { + __init__: function(unknownTypeId) + { + this._unknownTypeId = unknownTypeId; + }, + getUnknownTypeId: function() + { + return this._unknownTypeId; + }, + __write: function(os) + { + os.startWriteObject(this._slicedData); + os.endWriteObject(); + }, + __read: function(is) + { + is.startReadObject(); + this._slicedData = is.endReadObject(true); + } + }); + + Ice.SliceInfo = SliceInfo; + Ice.SlicedData = SlicedData; + Ice.UnknownSlicedObject = UnknownSlicedObject; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/browser/.gitignore b/js/src/Ice/browser/.gitignore new file mode 100644 index 00000000000..9c5c0a3f6d2 --- /dev/null +++ b/js/src/Ice/browser/.gitignore @@ -0,0 +1,2 @@ +ConnectionInfo.js +EndpointInfo.js diff --git a/js/src/Ice/browser/Buffer.js b/js/src/Ice/browser/Buffer.js new file mode 100644 index 00000000000..5d6c33393fe --- /dev/null +++ b/js/src/Ice/browser/Buffer.js @@ -0,0 +1,419 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + // + // IE 10 doesn't implement ArrayBuffer.slice + // + + if(!ArrayBuffer.prototype.slice) + { + ArrayBuffer.prototype.slice = function (start, end) + { + var b = new Uint8Array(this); + end = end === undefined ? b.length : end; + var result = new Uint8Array(new ArrayBuffer(end - start)); + for(var i = 0, length = result.length; i < length; i++) + { + result[i] = b[i + start]; + } + return result.buffer; + }; + } + + var __BufferOverflowException__ = "BufferOverflowException"; + var __BufferUnderflowException__ = "BufferUnderflowException"; + var __IndexOutOfBoundsException__ = "IndexOutOfBoundsException"; + + // + // Buffer implementation to be used by web browsers, it uses ArrayBuffer as + // the store. + // + + require("Ice/Class"); + require("Ice/Long"); + + var Ice = global.Ice || Ice; + var Long = Ice.Long; + + var Buffer = Ice.Class({ + __init__: function(buffer) + { + if(buffer !== undefined) + { + this.b = buffer; + this.v = new DataView(this.b); + } + else + { + this.b = null; // ArrayBuffer + this.v = null; // DataView + } + this._position = 0; + this._limit = 0; + this._shrinkCounter = 0; + }, + empty: function() + { + return this._limit === 0; + }, + resize: function(n) + { + if(n === 0) + { + this.clear(); + } + else if(n > this.capacity) + { + this.reserve(n); + } + this._limit = n; + }, + clear: function() + { + this.b = null; + this.v = null; + this._position = 0; + this._limit = 0; + }, + // + // Call expand(n) to add room for n additional bytes. Note that expand() + // examines the current position of the buffer first; we don't want to + // expand the buffer if the caller is writing to a location that is + // already in the buffer. + // + expand: function(n) + { + var sz = this.capacity === 0 ? n : this._position + n; + if(sz > this._limit) + { + this.resize(sz); + } + }, + reset: function() + { + if(this._limit > 0 && this._limit * 2 < this.capacity) + { + // + // If the current buffer size is smaller than the + // buffer capacity, we shrink the buffer memory to the + // current size. This is to avoid holding on to too much + // memory if it's not needed anymore. + // + if(++this._shrinkCounter > 2) + { + this.reserve(this._limit); + this._shrinkCounter = 0; + } + } + else + { + this._shrinkCounter = 0; + } + this._limit = 0; + this._position = 0; + }, + reserve: function(n) + { + if(n > this.capacity) + { + var capacity = Math.max(n, 2 * this.capacity); + capacity = Math.max(1024, capacity); + if(!this.b) + { + this.b = new ArrayBuffer(capacity); + } + else + { + var b = new Uint8Array(capacity); + b.set(new Uint8Array(this.b)); + this.b = b.buffer; + } + this.v = new DataView(this.b); + } + else if(n < this.capacity) + { + this.b = this.b.slice(0, this.capacity); + this.v = new DataView(this.b); + } + else + { + return; + } + }, + put: function(v) + { + if(this._position === this._limit) + { + throw new Error(__BufferOverflowException__); + } + this.v.setUint8(this._position, v); + this._position++; + }, + putAt: function(i, v) + { + if(i >= this._limit) + { + throw new Error(__IndexOutOfBoundsException__); + } + this.v.setUint8(i, v); + }, + putArray: function(v) + { + if(v.byteLength > 0) + { + //Expects an Uint8Array + if(this._position + v.length > this._limit) + { + throw new Error(__BufferOverflowException__); + } + new Uint8Array(this.b, 0, this.b.byteLength).set(v, this._position); + this._position += v.byteLength; + } + }, + putShort: function(v) + { + if(this._position + 2 > this._limit) + { + throw new Error(__BufferOverflowException__); + } + this.v.setInt16(this._position, v, true); + this._position += 2; + }, + putInt: function(v) + { + if(this._position + 4 > this._limit) + { + throw new Error(__BufferOverflowException__); + } + this.v.setInt32(this._position, v, true); + this._position += 4; + }, + putIntAt: function(i, v) + { + if(i + 4 > this._limit || i < 0) + { + throw new Error(__IndexOutOfBoundsException__); + } + this.v.setInt32(i, v, true); + }, + putFloat: function(v) + { + if(this._position + 4 > this._limit) + { + throw new Error(__BufferOverflowException__); + } + this.v.setFloat32(this._position, v, true); + this._position += 4; + }, + putDouble: function(v) + { + if(this._position + 8 > this._limit) + { + throw new Error(__BufferOverflowException__); + } + this.v.setFloat64(this._position, v, true); + this._position += 8; + }, + putLong: function(v) + { + if(this._position + 8 > this._limit) + { + throw new Error(__BufferOverflowException__); + } + this.v.setInt32(this._position, v.low, true); + this._position += 4; + this.v.setInt32(this._position, v.high, true); + this._position += 4; + }, + writeString: function(stream, v) + { + // + // Encode the string as utf8 + // + var encoded = unescape(encodeURIComponent(v)); + + stream.writeSize(encoded.length); + stream.expand(encoded.length); + this.putString(encoded, encoded.length); + }, + putString: function(v, sz) + { + if(this._position + sz > this._limit) + { + throw new Error(__BufferOverflowException__); + } + for(var i = 0; i < sz; ++i) + { + this.v.setUint8(this._position, v.charCodeAt(i)); + this._position++; + } + }, + get: function() + { + if(this._position >= this._limit) + { + throw new Error(__BufferUnderflowException__); + } + var v = this.v.getUint8(this._position); + this._position++; + return v; + }, + getAt: function(i) + { + if(i < 0 || i >= this._limit) + { + throw new Error(__IndexOutOfBoundsException__); + } + return this.v.getUint8(i); + }, + getArray: function(length) + { + if(this._position + length > this._limit) + { + throw new Error(__BufferUnderflowException__); + } + var buffer = this.b.slice(this._position, this._position + length); + this._position += length; + return new Uint8Array(buffer); + }, + getArrayAt: function(position, length) + { + if(position + length > this._limit) + { + throw new Error(__BufferUnderflowException__); + } + length = length === undefined ? (this.b.byteLength - position) : length; + return new Uint8Array(this.b.slice(position, position + length)); + }, + getShort: function() + { + if(this._limit - this._position < 2) + { + throw new Error(__BufferUnderflowException__); + } + var v = this.v.getInt16(this._position, true); + this._position += 2; + return v; + }, + getInt: function() + { + if(this._limit - this._position < 4) + { + throw new Error(__BufferUnderflowException__); + } + var v = this.v.getInt32(this._position, true); + this._position += 4; + return v; + }, + getFloat: function() + { + if(this._limit - this._position < 4) + { + throw new Error(__BufferUnderflowException__); + } + var v = this.v.getFloat32(this._position, true); + this._position += 4; + return v; + }, + getDouble: function() + { + if(this._limit - this._position < 8) + { + throw new Error(__BufferUnderflowException__); + } + var v = this.v.getFloat64(this._position, true); + this._position += 8; + return v; + }, + getLong: function() + { + if(this._limit - this._position < 8) + { + throw new Error(__BufferUnderflowException__); + } + var v = new Long(); + v.low = this.v.getInt32(this._position, true); + this._position += 4; + v.high = this.v.getInt32(this._position, true); + this._position += 4; + return v; + }, + getString: function(length) + { + if(this._position + length > this._limit) + { + throw new Error(__BufferUnderflowException__); + } + + var data = new DataView(this.b, this._position, length); + var s = ""; + + for(var i = 0; i < length; ++i) + { + s += String.fromCharCode(data.getUint8(i)); + } + this._position += length; + s = decodeURIComponent(escape(s)); + return s; + } + }); + + var prototype = Buffer.prototype; + + Object.defineProperty(prototype, "position", { + get: function() { return this._position; }, + set: function(position){ + if(position >= 0 && position <= this._limit) + { + this._position = position; + } + } + }); + + Object.defineProperty(prototype, "limit", { + get: function() { return this._limit; }, + set: function(limit){ + if(limit <= this.capacity) + { + this._limit = limit; + if(this._position > limit) + { + this._position = limit; + } + } + } + }); + + Object.defineProperty(prototype, "capacity", { + get: function() { return this.b === null ? 0 : this.b.byteLength; } + }); + + Object.defineProperty(prototype, "remaining", { + get: function() { return this._limit - this._position; } + }); + + // + // Create a native buffer from an array of bytes. + // + Buffer.createNative = function(data) + { + if(data === undefined) + { + return new Uint8Array(0); + } + else + { + return new Uint8Array(data); + } + }; + + Ice.Buffer = Buffer; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/browser/Debug.js b/js/src/Ice/browser/Debug.js new file mode 100644 index 00000000000..c6739e40ebd --- /dev/null +++ b/js/src/Ice/browser/Debug.js @@ -0,0 +1,41 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Exception"); + + var Ice = global.Ice || {}; + + var Exception = Ice.Exception; + + var AssertionFailedException = Ice.Class(Error, { + __init__: function(message) + { + Error.call(this); + Exception.captureStackTrace(this); + this.message = message; + } + }); + var Debug = {}; + + Debug.AssertionFailedException = AssertionFailedException; + + Debug.assert = function(b, msg) + { + if(!b) + { + console.log(msg === undefined ? "assertion failed" : msg); + console.log(Error().stack); + throw new AssertionFailedException(msg === undefined ? "assertion failed" : msg); + } + }; + Ice.Debug = Debug; + global.Ice = Ice; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/browser/EndpointFactory.js b/js/src/Ice/browser/EndpointFactory.js new file mode 100644 index 00000000000..c8481c654b5 --- /dev/null +++ b/js/src/Ice/browser/EndpointFactory.js @@ -0,0 +1,51 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Endpoint"); + + require("Ice/browser/EndpointInfo"); + require("Ice/browser/EndpointI"); + + var Ice = global.Ice || {}; + var IceWS = global.IceWS || {}; + + var EndpointI = IceWS.EndpointI; + + var EndpointFactory = Ice.Class({ + __init__:function(instance, secure) + { + this._instance = instance; + this._secure = secure; + }, + type: function() + { + return this._secure ? IceWS.WSSEndpointType : IceWS.WSEndpointType; + }, + protocol: function() + { + return this._secure ? "wss" : "ws"; + }, + create: function(str, oaEndpoint) + { + return EndpointI.fromString(this._instance, this._secure, str, oaEndpoint); + }, + read: function(s) + { + return EndpointI.fromStream(s, this._secure); + }, + destroy: function() + { + this._instance = null; + } + }); + IceWS.EndpointFactory = EndpointFactory; + global.IceWS = IceWS; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/browser/EndpointI.js b/js/src/Ice/browser/EndpointI.js new file mode 100644 index 00000000000..f364a087922 --- /dev/null +++ b/js/src/Ice/browser/EndpointI.js @@ -0,0 +1,543 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Address"); + require("Ice/HashUtil"); + require("Ice/StringUtil"); + require("Ice/Endpoint"); + require("Ice/LocalException"); + + require("Ice/browser/Transceiver"); + require("Ice/browser/EndpointInfo"); + + var Ice = global.Ice || {}; + var IceWS = global.IceWS || {}; + + var Address = Ice.Address; + var HashUtil = Ice.HashUtil; + var StringUtil = Ice.StringUtil; + var Transceiver = IceWS.Transceiver; + + var Class = Ice.Class; + + var EndpointI = Class(Ice.Endpoint, { + __init__: function(instance, secure, ho, po, ti, conId, co, re) + { + this._instance = instance; + this._secure = secure; + this._host = ho; + this._port = po; + this._timeout = ti; + this._connectionId = conId; + this._compress = co; + this._resource = re; + this.calcHashValue(); + }, + // + // Convert the endpoint to its string form + // + toString: function() + { + // + // WARNING: Certain features, such as proxy validation in Glacier2, + // depend on the format of proxy strings. Changes to toString() and + // methods called to generate parts of the reference string could break + // these features. Please review for all features that depend on the + // format of proxyToString() before changing this and related code. + // + var s = (this._secure ? "wss" : "ws"); + + if(this._host !== null && this._host.length > 0) + { + s += " -h "; + s += (this._host.indexOf(':') !== -1) ? ("\"" + this._host + "\"") : this._host; + } + + s += " -p " + this._port; + + if(this._timeout != -1) + { + s += " -t " + this._timeout; + } + if(this._compress) + { + s += " -z"; + } + if(this._resource !== null && this._resource.length > 0) + { + s += " -r "; + s += (this._resource.indexOf(':') !== -1) ? ("\"" + this._resource + "\"") : this._resource; + } + return s; + }, + // + // Return the endpoint information. + // + getInfo: function() + { + return new EndpointInfoI(this._secure, this._timeout, this._compress, this._host, this._port, this._resource); + }, + // + // Marshal the endpoint + // + streamWrite: function(s) + { + s.writeShort(this._secure ? IceWS.WSSEndpointType : IceWS.WSEndpointType); + s.startWriteEncaps(); + s.writeString(this._host); + s.writeInt(this._port); + s.writeInt(this._timeout); + s.writeBool(this._compress); + s.writeString(this._resource); + s.endWriteEncaps(); + }, + // + // Return the endpoint type + // + type: function() + { + return this._secure ? IceWS.WSSEndpointType : IceWS.WSEndpointType; + }, + // + // Return the timeout for the endpoint in milliseconds. 0 means + // non-blocking, -1 means no timeout. + // + timeout: function() + { + return this._timeout; + }, + // + // Return a new endpoint with a different timeout value, provided + // that timeouts are supported by the endpoint. Otherwise the same + // endpoint is returned. + // + changeTimeout: function(timeout) + { + if(timeout === this._timeout) + { + return this; + } + else + { + return new EndpointI(this._instance, this._secure, this._host, this._port, timeout, this._connectionId, this._compress, this._resource); + } + }, + // + // Return a new endpoint with a different connection id. + // + changeConnectionId: function(connectionId) + { + if(connectionId === this._connectionId) + { + return this; + } + else + { + return new EndpointI(this._instance, this._secure, this._host, this._port, this._timeout, connectionId, this._compress, this._resource); + } + }, + // + // Return true if the endpoints support bzip2 compress, or false + // otherwise. + // + compress: function() + { + return this._compress; + }, + // + // Return a new endpoint with a different compression value, + // provided that compression is supported by the + // endpoint. Otherwise the same endpoint is returned. + // + changeCompress: function(compress) + { + if(compress === this._compress) + { + return this; + } + else + { + return new EndpointI(this._instance, this._secure, this._host, this._port, this._timeout, this._connectionId, compress, this._resource); + } + }, + // + // Return true if the endpoint is datagram-based. + // + datagram: function() + { + return false; + }, + // + // Return true if the endpoint is secure. + // + secure: function() + { + return this._secure; + }, + // + // Return a server side transceiver for this endpoint, or null if a + // transceiver can only be created by an acceptor. In case a + // transceiver is created, this operation also returns a new + // "effective" endpoint, which might differ from this endpoint, + // for example, if a dynamic port number is assigned. + // + transceiver: function(endpoint) + { + return null; + }, + // + // Return an acceptor for this endpoint, or null if no acceptors + // is available. In case an acceptor is created, this operation + // also returns a new "effective" endpoint, which might differ + // from this endpoint, for example, if a dynamic port number is + // assigned. + // + acceptor: function(endpoint, adapterName) + { + return null; + }, + connect: function() + { + if(this._instance.traceLevels().network >= 2) + { + this._instance.initializationData().logger.trace(this._instance.traceLevels().networkCat, + "trying to establish " + (this._secure ? "wss" : "ws") + " connection to " + this._host + ":" + + this._port); + } + + return Transceiver.createOutgoing(this._instance, this._secure, new Address(this._host, this._port), + this._resource); + }, + hashCode: function() + { + return this._hashCode; + }, + // + // Compare endpoints for sorting purposes + // + equals: function(p) + { + if(!(p instanceof EndpointI)) + { + return false; + } + + if(this === p) + { + return true; + } + + if(this._host !== p._host) + { + return false; + } + + if(this._port !== p._port) + { + return false; + } + + if(this._timeout !== p._timeout) + { + return false; + } + + if(this._connectionId !== p._connectionId) + { + return false; + } + + if(this._compress !== p._compress) + { + return false; + } + + if(this._resource !== p._resource) + { + return false; + } + + return true; + }, + compareTo: function(p) + { + if(this === p) + { + return 0; + } + + if(p === null) + { + return 1; + } + + if(!(p instanceof EndpointI)) + { + return this.type() < p.type() ? -1 : 1; + } + + if(this._port < p._port) + { + return -1; + } + else if(p._port < this._port) + { + return 1; + } + + if(this._timeout < p._timeout) + { + return -1; + } + else if(p._timeout < this._timeout) + { + return 1; + } + + if(this._connectionId != p._connectionId) + { + return this._connectionId < p._connectionId ? -1 : 1; + } + + if(!this._compress && p._compress) + { + return -1; + } + else if(!p._compress && this._compress) + { + return 1; + } + + if(this._host < p._host) + { + return -1; + } + else if(p._host < this._host) + { + return 1; + } + + if(this._resource == p._resource) + { + return 0; + } + else + { + return this._resource < p._resource ? -1 : 1; + } + }, + calcHashValue: function() + { + var h = 5381; + h = HashUtil.addNumber(h, this._secure ? IceWS.WSSEndpointType : IceWS.WSEndpointType); + h = HashUtil.addString(h, this._host); + h = HashUtil.addNumber(h, this._port); + h = HashUtil.addNumber(h, this._timeout); + h = HashUtil.addString(h, this._connectionId); + h = HashUtil.addBoolean(h, this._compress); + h = HashUtil.addString(h, this._resource); + this._hashCode = h; + } + }); + + EndpointI.fromString = function(instance, secure, str, oaEndpoint) + { + var host = null; + var port = 0; + var timeout = -1; + var compress = false; + var resource = ""; + + var protocol = secure ? "wss" : "ws"; + + var arr = str.split(/[ \t\n\r]+/); + + var i = 0; + while(i < arr.length) + { + if(arr[i].length === 0) + { + i++; + continue; + } + + var option = arr[i++]; + if(option.length != 2 && option.charAt(0) != '-') + { + throw new Ice.EndpointParseException("expected an endpoint option but found `" + option + + "' in endpoint `" + protocol + " " + str + "'"); + } + + var argument = null; + if(i < arr.length && arr[i].charAt(0) != '-') + { + argument = arr[i++]; + if(argument.charAt(0) == '\"' && argument.charAt(argument.length - 1) == '\"') + { + argument = argument.substring(1, argument.length - 1); + } + } + + switch(option.charAt(1)) + { + case 'h': + { + if(argument === null) + { + throw new Ice.EndpointParseException("no argument provided for -h option in endpoint `" + + protocol + " " + str + "'"); + } + + host = argument; + break; + } + + case 'p': + { + if(argument === null) + { + throw new Ice.EndpointParseException("no argument provided for -p option in endpoint `" + + protocol + " " + str + "'"); + } + + try + { + port = StringUtil.toInt(argument); + } + catch(ex) + { + throw new Ice.EndpointParseException("invalid port value `" + argument + + "' in endpoint `" + protocol + " " + str + "'"); + } + + if(port < 0 || port > 65535) + { + throw new Ice.EndpointParseException("port value `" + argument + + "' out of range in endpoint `" + protocol + " " + str + + "'"); + } + + break; + } + + case 'r': + { + if(argument === null) + { + throw new Ice.EndpointParseException("no argument provided for -r option in endpoint `" + + protocol + " " + str + "'"); + } + + resource = argument; + break; + } + + case 't': + { + if(argument === null) + { + throw new Ice.EndpointParseException("no argument provided for -t option in endpoint `" + + protocol + " " + str + "'"); + } + + try + { + timeout = StringUtil.toInt(argument); + } + catch(ex) + { + throw new Ice.EndpointParseException("invalid timeout value `" + argument + + "' in endpoint `" + protocol + " " + str + "'"); + } + + break; + } + + case 'z': + { + if(argument !== null) + { + throw new Ice.EndpointParseException("unexpected argument `" + argument + + "' provided for -z option in `" + protocol + " " + str + + "'"); + } + + compress = true; + break; + } + + default: + { + throw new Ice.EndpointParseException("unknown option `" + option + "' in `" + protocol + " " + + str + "'"); + } + } + } + + if(host === null) + { + host = instance.defaultsAndOverrides().defaultHost; + } + else if(host == "*") + { + if(oaEndpoint) + { + host = null; + } + else + { + throw new Ice.EndpointParseException("`-h *' not valid for proxy endpoint `" + protocol + " " + str + + "'"); + } + } + + if(host === null) + { + host = ""; + } + return new EndpointI(instance, secure, host, port, timeout, "", compress, resource); + }; + + EndpointI.fromStream = function(s, secure) + { + s.startReadEncaps(); + var host = s.readString(); + var port = s.readInt(); + var timeout = s.readInt(); + var compress = s.readBool(); + var resource = s.readString(); + s.endReadEncaps(); + return new EndpointI(s.instance, secure, host, port, timeout, "", compress, resource); + }; + + IceWS.EndpointI = EndpointI; + global.IceWS = IceWS; + + var EndpointInfoI = Class(IceWS.EndpointInfo, { + __init__: function(secure, timeout, compress, host, port, resource) + { + IceWS.EndpointInfo.call(this, timeout, compress, host, port, resource); + this.secure = secure; + }, + type: function() + { + return this._secure ? IceWS.WSSEndpointType : IceWS.WSEndpointType; + }, + datagram: function() + { + return false; + }, + secure: function() + { + return this._secure; + } + }); +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/browser/Transceiver.js b/js/src/Ice/browser/Transceiver.js new file mode 100644 index 00000000000..f700dfbfc55 --- /dev/null +++ b/js/src/Ice/browser/Transceiver.js @@ -0,0 +1,418 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(global){ + require("Ice/Class"); + require("Ice/Debug"); + require("Ice/ExUtil"); + require("Ice/Network"); + require("Ice/SocketOperation"); + require("Ice/Connection"); + require("Ice/Exception"); + require("Ice/LocalException"); + + require("Ice/browser/ConnectionInfo"); + + var Ice = global.Ice || {}; + var IceWS = global.IceWS || {}; + + var Debug = Ice.Debug; + var ExUtil = Ice.ExUtil; + var Network = Ice.Network; + var SocketOperation = Ice.SocketOperation; + var Conn = Ice.Connection; + var LocalException = Ice.LocalException; + var SocketException = Ice.SocketException; + + var StateNeedConnect = 0; + var StateConnectPending = 1; + var StateConnected = 2; + var StateClosePending = 3; + var StateClosed = 4; + + var IsFirefox = navigator.userAgent.indexOf("Firefox") !== -1; + + var Transceiver = Ice.Class({ + __init__: function(instance) + { + this._traceLevels = instance.traceLevels(); + this._logger = instance.initializationData().logger; + this._readBuffers = []; + this._readPosition = 0; + }, + setCallbacks: function(connectedCallback, bytesAvailableCallback, bytesWrittenCallback) + { + this._connectedCallback = connectedCallback; + this._bytesAvailableCallback = bytesAvailableCallback; + this._bytesWrittenCallback = bytesWrittenCallback; + }, + // + // Returns SocketOperation.None when initialization is complete. + // + initialize: function(readBuffer, writeBuffer) + { + try + { + if(this._exception) + { + throw this._exception; + } + + if(this._state === StateNeedConnect) + { + this._state = StateConnectPending; + this._fd = new WebSocket(this._url, "ice.zeroc.com"); + this._fd.binaryType = "arraybuffer"; + var self = this; + this._fd.onopen = function(e) { self.socketConnected(e); }; + this._fd.onmessage = function(e) { self.socketBytesAvailable(e.data); }; + this._fd.onclose = function(e) { self.socketClosed(e); }; + return SocketOperation.Connect; // Waiting for connect to complete. + } + else if(this._state === StateConnectPending) + { + // + // Socket is connected. + // + this._desc = fdToString(this._addr); + this._state = StateConnected; + } + } + catch(err) + { + if(!this._exception) + { + this._exception = translateError(this._state, err); + } + + if(this._traceLevels.network >= 2) + { + var s = []; + s.push("failed to establish " + this.type() + " connection\n"); + s.push(fdToString(this._addr)); + this._logger.trace(this._traceLevels.networkCat, s.join("")); + } + throw this._exception; + } + + Debug.assert(this._state === StateConnected); + if(this._traceLevels.network >= 1) + { + this._logger.trace(this._traceLevels.networkCat, this.type() + + " connection established\n" + this._desc); + } + return SocketOperation.None; + }, + register: function() + { + // + // Register the socket data listener. + // + this._registered = true; + if(this._hasBytesAvailable || this._exception) + { + this._bytesAvailableCallback(); + this._hasBytesAvailable = false; + } + }, + unregister: function() + { + // + // Unregister the socket data listener. + // + this._registered = false; + }, + close: function() + { + if(this._fd === null) + { + Debug.assert(this._exception); // Websocket creation failed. + return; + } + + // + // WORKAROUND: With Firefox, calling close() if the websocket isn't connected + // yet doesn't close the connection. The server doesn't receive any close frame + // and the underlying socket isn't closed causing the server to hang on closing + // the connection until the browser exits. + // + // To workaround this problem, we always wait for the socket to be connected + // or closed before closing the socket. + // + if(this._fd.readyState === WebSocket.CONNECTING && IsFirefox) + { + this._state = StateClosePending; + return; + } + + if(this._state == StateConnected && this._traceLevels.network >= 1) + { + this._logger.trace(this._traceLevels.networkCat, "closing " + this.type() + " connection\n" + + this._desc); + } + + Debug.assert(this._fd !== null); + try + { + this._state = StateClosed; + this._fd.close(); + } + catch(ex) + { + throw translateError(this._state, ex); + } + finally + { + this._fd = null; + } + }, + // + // Returns true if all of the data was flushed to the kernel buffer. + // + write: function(byteBuffer) + { + if(this._exception) + { + throw this._exception; + } + + var remaining = byteBuffer.remaining; + Debug.assert(remaining > 0); + Debug.assert(this._fd); + + // + // Delay the send if more than 1KB is already queued for + // sending on the socket. If less, we consider that it's + // fine to push more data on the socket. + // + if(this._fd.bufferedAmount < 1024) + { + // + // Create a slice of the source buffer representing the remaining data to be written. + // + var slice = byteBuffer.b.slice(byteBuffer.position, byteBuffer.position + remaining); + + // + // The socket will accept all of the data. + // + byteBuffer.position = byteBuffer.position + remaining; + this._fd.send(slice); + if(remaining > 0 && this._traceLevels.network >= 3) + { + var msg = "sent " + remaining + " of " + remaining + " bytes via " + this.type() + "\n" +this._desc; + this._logger.trace(this._traceLevels.networkCat, msg); + } + return true; + } + else + { + var transceiver = this; + var writtenCB = function() + { + if(transceiver._fd) + { + if(transceiver._fd.bufferedAmount === 0 || this._exception) + { + transceiver._bytesWrittenCallback(); + } + else + { + setTimeout(writtenCB, 50); + } + } + }; + setTimeout(writtenCB, 50); + return false; + } + }, + read: function(byteBuffer, moreData) + { + if(this._exception) + { + throw this._exception; + } + + moreData.value = false; + + if(this._readBuffers.length === 0) + { + return false; // No data available. + } + + var avail = this._readBuffers[0].byteLength - this._readPosition; + Debug.assert(avail > 0); + var remaining = byteBuffer.remaining; + + while(byteBuffer.remaining > 0) + { + if(avail > byteBuffer.remaining) + { + avail = byteBuffer.remaining; + } + + new Uint8Array(byteBuffer.b).set(new Uint8Array(this._readBuffers[0], this._readPosition, avail), + byteBuffer.position); + + byteBuffer.position += avail; + this._readPosition += avail; + if(this._readPosition === this._readBuffers[0].byteLength) + { + // + // We've exhausted the current read buffer. + // + this._readPosition = 0; + this._readBuffers.shift(); + if(this._readBuffers.length === 0) + { + break; // No more data - we're done. + } + else + { + avail = this._readBuffers[0].byteLength; + } + } + } + + var n = remaining - byteBuffer.remaining; + if(n > 0 && this._traceLevels.network >= 3) + { + var msg = "received " + n + " of " + remaining + " bytes via " + this.type() + "\n" + this._desc; + this._logger.trace(this._traceLevels.networkCat, msg); + } + + moreData.value = this._readBuffers.byteLength > 0; + + return byteBuffer.remaining === 0; + }, + type: function() + { + return this._secure ? "wss" : "ws"; + }, + getInfo: function() + { + Debug.assert(this._fd !== null); + var info = this.createInfo(); + + // + // The WebSocket API doens't provide this info + // + info.localAddress = ""; + info.localPort = -1; + info.remoteAddress = this._addr.host; + info.remotePort = this._addr.port; + return info; + }, + createInfo: function() + { + return new IceWS.ConnectionInfo(); + }, + checkSendSize: function(stream, messageSizeMax) + { + if(stream.size > messageSizeMax) + { + ExUtil.throwMemoryLimitException(stream.size, messageSizeMax); + } + }, + toString: function() + { + return this._desc; + }, + socketConnected: function(e) + { + if(this._state == StateClosePending) + { + this.close(); + return; + } + + Debug.assert(this._connectedCallback !== null); + this._connectedCallback(); + }, + socketBytesAvailable: function(buf) + { + Debug.assert(this._bytesAvailableCallback !== null); + if(buf.byteLength > 0) + { + this._readBuffers.push(buf); + if(this._registered) + { + this._bytesAvailableCallback(); + } + else if(!this._hasBytesAvailable) + { + this._hasBytesAvailable = true; + } + } + }, + socketClosed: function(err) + { + if(this._state == StateClosePending) + { + this.close(); + return; + } + + this._exception = translateError(this._state, err); + if(this._state < StateConnected) + { + this._connectedCallback(); + } + else if(this._registered) + { + this._bytesAvailableCallback(); + } + }, + }); + + function fdToString(address) + { + return "local address = <not available>\nremote address = " + address.host + ":" + address.port; + } + + function translateError(state, err) + { + if(state < StateConnected) + { + return new Ice.ConnectFailedException(err.code, err); + } + else + { + if(err === 1000) // CLOSE_NORMAL + { + throw new Ice.ConnectionLostException(); + } + return new Ice.SocketException(err.code, err); + } + } + + Transceiver.createOutgoing = function(instance, secure, addr, resource) + { + var transceiver = new Transceiver(instance); + + var url = secure ? "wss" : "ws"; + url += "://" + addr.host; + if(addr.port !== 80) + { + url += ":" + addr.port; + } + url += resource ? resource : "/"; + transceiver._url = url; + transceiver._fd = null; + transceiver._addr = addr; + transceiver._desc = "remote address: " + addr.host + ":" + addr.port + " <not connected>"; + transceiver._state = StateNeedConnect; + transceiver._secure = secure; + transceiver._exception = null; + + return transceiver; + }; + + IceWS.Transceiver = Transceiver; + global.IceWS = IceWS; +}(typeof (global) === "undefined" ? window : global)); diff --git a/js/src/Ice/package.json b/js/src/Ice/package.json new file mode 100644 index 00000000000..c5e32a6ea18 --- /dev/null +++ b/js/src/Ice/package.json @@ -0,0 +1,5 @@ +{ + "name": "Ice", + "version": "0.1.0", + "main": "Ice.js" +} diff --git a/js/src/IceGrid/.gitignore b/js/src/IceGrid/.gitignore new file mode 100644 index 00000000000..2cd3235f4ad --- /dev/null +++ b/js/src/IceGrid/.gitignore @@ -0,0 +1,10 @@ +Admin.js +Descriptor.js +Exception.js +FileParser.js +Locator.js +Observer.js +Query.js +Registry.js +Session.js +UserAccountMapper.js diff --git a/js/src/IceGrid/IceGrid.js b/js/src/IceGrid/IceGrid.js new file mode 100644 index 00000000000..413b0fd0aa9 --- /dev/null +++ b/js/src/IceGrid/IceGrid.js @@ -0,0 +1,21 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +(function(){ + require("IceGrid/Admin"); + require("IceGrid/Descriptor"); + require("IceGrid/Exception"); + require("IceGrid/FileParser"); + require("IceGrid/Locator"); + require("IceGrid/Observer"); + require("IceGrid/Query"); + require("IceGrid/Registry"); + require("IceGrid/Session"); + require("IceGrid/UserAccountMapper"); +}()); diff --git a/js/src/IceGrid/Makefile b/js/src/IceGrid/Makefile new file mode 100644 index 00000000000..0d952c92ced --- /dev/null +++ b/js/src/IceGrid/Makefile @@ -0,0 +1,43 @@ +# ********************************************************************** +# +# Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +# +# This copy of Ice is licensed to you under the terms described in the +# ICE_LICENSE file included in this distribution. +# +# ********************************************************************** + +top_srcdir = ../.. + +LIBNAME = IceGrid + +TARGETS = $(call mklibtargets,$(LIBNAME)) + +SLICES = $(SDIR)/Admin.ice \ + $(SDIR)/Descriptor.ice \ + $(SDIR)/Exception.ice \ + $(SDIR)/FileParser.ice \ + $(SDIR)/Locator.ice \ + $(SDIR)/Observer.ice \ + $(SDIR)/Query.ice \ + $(SDIR)/Registry.ice \ + $(SDIR)/Session.ice \ + $(SDIR)/UserAccountMapper.ice + +SDIR = $(slicedir)/IceGrid + +GEN_SRCS = $(patsubst $(SDIR)/%.ice, %.js, $(SLICES)) + +SRCS := $(GEN_SRCS) +INSTALL_SRCS := IceGrid.js $(GEN_SRCS) + +include $(top_srcdir)/config/Make.rules.js + +SLICE2JSFLAGS := $(SLICE2JSFLAGS) --ice -I$(slicedir) + +lint:: $(INSTALL_SRCS) + jshint $(LINTFLAGS) $(INSTALL_SRCS) + +install:: all + $(call installlib,$(DESTDIR)$(install_libdir),$(libdir),$(LIBNAME)) + $(call installmodule,$(DESTDIR)$(install_moduledir),$(INSTALL_SRCS),$(LIBNAME)) diff --git a/js/src/IceGrid/Makefile.mak b/js/src/IceGrid/Makefile.mak new file mode 100644 index 00000000000..f64be2a73c6 --- /dev/null +++ b/js/src/IceGrid/Makefile.mak @@ -0,0 +1,42 @@ +# ********************************************************************** +# +# Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +# +# This copy of Ice is licensed to you under the terms described in the +# ICE_LICENSE file included in this distribution. +# +# ********************************************************************** + +top_srcdir = ..\.. + +LIBNAME = IceGrid + +GEN_SRCS = Admin.js \ + Descriptor.js \ + Exception.js \ + FileParser.js \ + Locator.js \ + Observer.js \ + Query.js \ + Registry.js \ + Session.js \ + UserAccountMapper.js + +SDIR = $(slicedir)\IceGrid + +SRCS = $(GEN_SRCS) +INSTALL_SRCS = IceGrid.js $(GEN_SRCS) + +!include $(top_srcdir)\config\Make.rules.mak.js + +SLICE2JSFLAGS = $(SLICE2JSFLAGS) --ice -I"$(slicedir)" + +MODULEDIR = $(install_moduledir)\$(LIBNAME) + +install:: all + @if not exist $(MODULEDIR) \ + @echo "Creating $(MODULEDIR)" && \ + mkdir "$(MODULEDIR)" + @for %i in ( $(INSTALL_SRCS) ) do \ + copy %i "$(MODULEDIR)" + copy package.json "$(MODULEDIR)" diff --git a/js/src/IceGrid/package.json b/js/src/IceGrid/package.json new file mode 100644 index 00000000000..d928926a5e1 --- /dev/null +++ b/js/src/IceGrid/package.json @@ -0,0 +1,5 @@ +{ + "name": "IceGrid", + "version": "0.1.0", + "main": "IceGrid.js" +} diff --git a/js/src/IceStorm/.gitignore b/js/src/IceStorm/.gitignore new file mode 100644 index 00000000000..1e3e811ef95 --- /dev/null +++ b/js/src/IceStorm/.gitignore @@ -0,0 +1,2 @@ +IceStorm.js +Metrics.js diff --git a/js/src/IceStorm/Makefile b/js/src/IceStorm/Makefile new file mode 100644 index 00000000000..876c8e05439 --- /dev/null +++ b/js/src/IceStorm/Makefile @@ -0,0 +1,35 @@ +# ********************************************************************** +# +# Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +# +# This copy of Ice is licensed to you under the terms described in the +# ICE_LICENSE file included in this distribution. +# +# ********************************************************************** + +top_srcdir = ../.. + +LIBNAME = IceStorm + +TARGETS = $(call mklibtargets,$(LIBNAME)) + +SLICES = $(SDIR)/IceStorm.ice \ + $(SDIR)/Metrics.ice + +SDIR = $(slicedir)/IceStorm + +GEN_SRCS = $(patsubst $(SDIR)/%.ice, %.js, $(SLICES)) + +SRCS := $(GEN_SRCS) +INSTALL_SRCS := IceStorm.js $(GEN_SRCS) + +include $(top_srcdir)/config/Make.rules.js + +SLICE2JSFLAGS := $(SLICE2JSFLAGS) --ice -I$(slicedir) + +lint:: $(INSTALL_SRCS) + jshint $(LINTFLAGS) $(INSTALL_SRCS) + +install:: all + $(call installlib,$(DESTDIR)$(install_libdir),$(libdir),$(LIBNAME)) + $(call installmodule,$(DESTDIR)$(install_moduledir),$(INSTALL_SRCS),$(LIBNAME)) diff --git a/js/src/IceStorm/Makefile.mak b/js/src/IceStorm/Makefile.mak new file mode 100644 index 00000000000..073ab55fca9 --- /dev/null +++ b/js/src/IceStorm/Makefile.mak @@ -0,0 +1,34 @@ +# ********************************************************************** +# +# Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +# +# This copy of Ice is licensed to you under the terms described in the +# ICE_LICENSE file included in this distribution. +# +# ********************************************************************** + +top_srcdir = ..\.. + +LIBNAME = IceStorm + +GEN_SRCS = IceStorm.js \ + Metrics.js + +SDIR = $(slicedir)\IceStorm + +SRCS = $(GEN_SRCS) +INSTALL_SRCS = IceStorm.js $(GEN_SRCS) + +!include $(top_srcdir)\config\Make.rules.mak.js + +SLICE2JSFLAGS = $(SLICE2JSFLAGS) --ice -I"$(slicedir)" + +MODULEDIR = $(install_moduledir)\$(LIBNAME) + +install:: all + @if not exist $(MODULEDIR) \ + @echo "Creating $(MODULEDIR)" && \ + mkdir "$(MODULEDIR)" + @for %i in ( $(INSTALL_SRCS) ) do \ + copy %i "$(MODULEDIR)" + copy package.json "$(MODULEDIR)" diff --git a/js/src/IceStorm/package.json b/js/src/IceStorm/package.json new file mode 100644 index 00000000000..c41a8446174 --- /dev/null +++ b/js/src/IceStorm/package.json @@ -0,0 +1,5 @@ +{ + "name": "IceStorm", + "version": "0.1.0", + "main": "IceStorm.js" +} diff --git a/js/src/Makefile b/js/src/Makefile new file mode 100644 index 00000000000..8144440381c --- /dev/null +++ b/js/src/Makefile @@ -0,0 +1,33 @@ +# ********************************************************************** +# +# Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +# +# This copy of Ice is licensed to you under the terms described in the +# ICE_LICENSE file included in this distribution. +# +# ********************************************************************** + +top_srcdir = .. + +include $(top_srcdir)/config/Make.rules.js + +SUBDIRS = Ice Glacier2 IceStorm IceGrid + +.PHONY: $(EVERYTHING) $(SUBDIRS) + + +all:: $(SUBDIRS) + +$(SUBDIRS): + @echo "making all in $@" + @$(MAKE) all --directory=$@ + +$(EVERYTHING_EXCEPT_ALL):: + @for subdir in $(SUBDIRS); \ + do \ + if test -d $$subdir ; \ + then \ + echo "making $@ in $$subdir"; \ + ( cd $$subdir && $(MAKE) $@ ) || exit 1; \ + fi; \ + done diff --git a/js/src/Makefile.mak b/js/src/Makefile.mak new file mode 100644 index 00000000000..d87264e34a1 --- /dev/null +++ b/js/src/Makefile.mak @@ -0,0 +1,19 @@ +# ********************************************************************** +# +# Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved. +# +# This copy of Ice is licensed to you under the terms described in the +# ICE_LICENSE file included in this distribution. +# +# ********************************************************************** + +top_srcdir = .. + +!include $(top_srcdir)\config\Make.rules.mak.js + +SUBDIRS = Ice Glacier2 IceStorm IceGrid + +$(EVERYTHING):: + @for %i in ( $(SUBDIRS) ) do \ + @echo "making $@ in %i" && \ + cmd /c "cd %i && $(MAKE) -nologo -f Makefile.mak $@" || exit 1 |