| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| /*jshint evil:true*/ |
| |
| /** |
| * The Thrift namespace houses the Apache Thrift JavaScript library |
| * elements providing JavaScript bindings for the Apache Thrift RPC |
| * system. End users will typically only directly make use of the |
| * Transport (TXHRTransport/TWebSocketTransport) and Protocol |
| * (TJSONPRotocol/TBinaryProtocol) constructors. |
| * |
| * Object methods beginning with a __ (e.g. __onOpen()) are internal |
| * and should not be called outside of the object's own methods. |
| * |
| * This library creates one global object: Thrift |
| * Code in this library must never create additional global identifiers, |
| * all features must be scoped within the Thrift namespace. |
| * @namespace |
| * @example |
| * var transport = new Thrift.Transport("http://localhost:8585"); |
| * var protocol = new Thrift.Protocol(transport); |
| * var client = new MyThriftSvcClient(protocol); |
| * var result = client.MyMethod(); |
| */ |
| var Thrift = { |
| /** |
| * Thrift JavaScript library version. |
| * @readonly |
| * @const {string} Version |
| * @memberof Thrift |
| */ |
| Version: '1.0.0-dev', |
| |
| /** |
| * Thrift IDL type string to Id mapping. |
| * @readonly |
| * @property {number} STOP - End of a set of fields. |
| * @property {number} VOID - No value (only legal for return types). |
| * @property {number} BOOL - True/False integer. |
| * @property {number} BYTE - Signed 8 bit integer. |
| * @property {number} I08 - Signed 8 bit integer. |
| * @property {number} DOUBLE - 64 bit IEEE 854 floating point. |
| * @property {number} I16 - Signed 16 bit integer. |
| * @property {number} I32 - Signed 32 bit integer. |
| * @property {number} I64 - Signed 64 bit integer. |
| * @property {number} STRING - Array of bytes representing a string of characters. |
| * @property {number} UTF7 - Array of bytes representing a string of UTF7 encoded characters. |
| * @property {number} STRUCT - A multifield type. |
| * @property {number} MAP - A collection type (map/associative-array/dictionary). |
| * @property {number} SET - A collection type (unordered and without repeated values). |
| * @property {number} LIST - A collection type (unordered). |
| * @property {number} UTF8 - Array of bytes representing a string of UTF8 encoded characters. |
| * @property {number} UTF16 - Array of bytes representing a string of UTF16 encoded characters. |
| */ |
| Type: { |
| 'STOP' : 0, |
| 'VOID' : 1, |
| 'BOOL' : 2, |
| 'BYTE' : 3, |
| 'I08' : 3, |
| 'DOUBLE' : 4, |
| 'I16' : 6, |
| 'I32' : 8, |
| 'I64' : 10, |
| 'STRING' : 11, |
| 'UTF7' : 11, |
| 'STRUCT' : 12, |
| 'MAP' : 13, |
| 'SET' : 14, |
| 'LIST' : 15, |
| 'UTF8' : 16, |
| 'UTF16' : 17 |
| }, |
| |
| /** |
| * Thrift RPC message type string to Id mapping. |
| * @readonly |
| * @property {number} CALL - RPC call sent from client to server. |
| * @property {number} REPLY - RPC call normal response from server to client. |
| * @property {number} EXCEPTION - RPC call exception response from server to client. |
| * @property {number} ONEWAY - Oneway RPC call from client to server with no response. |
| */ |
| MessageType: { |
| 'CALL' : 1, |
| 'REPLY' : 2, |
| 'EXCEPTION' : 3, |
| 'ONEWAY' : 4 |
| }, |
| |
| /** |
| * Utility function returning the count of an object's own properties. |
| * @param {object} obj - Object to test. |
| * @returns {number} number of object's own properties |
| */ |
| objectLength: function(obj) { |
| var length = 0; |
| for (var k in obj) { |
| if (obj.hasOwnProperty(k)) { |
| length++; |
| } |
| } |
| return length; |
| }, |
| |
| /** |
| * Utility function to establish prototype inheritance. |
| * @see {@link http://javascript.crockford.com/prototypal.html|Prototypal Inheritance} |
| * @param {function} constructor - Contstructor function to set as derived. |
| * @param {function} superConstructor - Contstructor function to set as base. |
| * @param {string} [name] - Type name to set as name property in derived prototype. |
| */ |
| inherits: function(constructor, superConstructor, name) { |
| function F() {} |
| F.prototype = superConstructor.prototype; |
| constructor.prototype = new F(); |
| constructor.prototype.name = name || ""; |
| } |
| }; |
| |
| /** |
| * Initializes a Thrift TException instance. |
| * @constructor |
| * @augments Error |
| * @param {string} message - The TException message (distinct from the Error message). |
| * @classdesc TException is the base class for all Thrift exceptions types. |
| */ |
| Thrift.TException = function(message) { |
| this.message = message; |
| }; |
| Thrift.inherits(Thrift.TException, Error, 'TException'); |
| |
| /** |
| * Returns the message set on the exception. |
| * @readonly |
| * @returns {string} exception message |
| */ |
| Thrift.TException.prototype.getMessage = function() { |
| return this.message; |
| }; |
| |
| /** |
| * Thrift Application Exception type string to Id mapping. |
| * @readonly |
| * @property {number} UNKNOWN - Unknown/undefined. |
| * @property {number} UNKNOWN_METHOD - Client attempted to call a method unknown to the server. |
| * @property {number} INVALID_MESSAGE_TYPE - Client passed an unknown/unsupported MessageType. |
| * @property {number} WRONG_METHOD_NAME - Unused. |
| * @property {number} BAD_SEQUENCE_ID - Unused in Thrift RPC, used to flag proprietary sequence number errors. |
| * @property {number} MISSING_RESULT - Raised by a server processor if a handler fails to supply the required return result. |
| * @property {number} INTERNAL_ERROR - Something bad happened. |
| * @property {number} PROTOCOL_ERROR - The protocol layer failed to serialize or deserialize data. |
| * @property {number} INVALID_TRANSFORM - Unused. |
| * @property {number} INVALID_PROTOCOL - The protocol (or version) is not supported. |
| * @property {number} UNSUPPORTED_CLIENT_TYPE - Unused. |
| */ |
| Thrift.TApplicationExceptionType = { |
| 'UNKNOWN' : 0, |
| 'UNKNOWN_METHOD' : 1, |
| 'INVALID_MESSAGE_TYPE' : 2, |
| 'WRONG_METHOD_NAME' : 3, |
| 'BAD_SEQUENCE_ID' : 4, |
| 'MISSING_RESULT' : 5, |
| 'INTERNAL_ERROR' : 6, |
| 'PROTOCOL_ERROR' : 7, |
| 'INVALID_TRANSFORM' : 8, |
| 'INVALID_PROTOCOL' : 9, |
| 'UNSUPPORTED_CLIENT_TYPE' : 10 |
| }; |
| |
| /** |
| * Initializes a Thrift TApplicationException instance. |
| * @constructor |
| * @augments Thrift.TException |
| * @param {string} message - The TApplicationException message (distinct from the Error message). |
| * @param {Thrift.TApplicationExceptionType} [code] - The TApplicationExceptionType code. |
| * @classdesc TApplicationException is the exception class used to propagate exceptions from an RPC server back to a calling client. |
| */ |
| Thrift.TApplicationException = function(message, code) { |
| this.message = message; |
| this.code = typeof code === "number" ? code : 0; |
| }; |
| Thrift.inherits(Thrift.TApplicationException, Thrift.TException, 'TApplicationException'); |
| |
| /** |
| * Read a TApplicationException from the supplied protocol. |
| * @param {object} input - The input protocol to read from. |
| */ |
| Thrift.TApplicationException.prototype.read = function(input) { |
| while (1) { |
| var ret = input.readFieldBegin(); |
| |
| if (ret.ftype == Thrift.Type.STOP) { |
| break; |
| } |
| |
| var fid = ret.fid; |
| |
| switch (fid) { |
| case 1: |
| if (ret.ftype == Thrift.Type.STRING) { |
| ret = input.readString(); |
| this.message = ret.value; |
| } else { |
| ret = input.skip(ret.ftype); |
| } |
| break; |
| case 2: |
| if (ret.ftype == Thrift.Type.I32) { |
| ret = input.readI32(); |
| this.code = ret.value; |
| } else { |
| ret = input.skip(ret.ftype); |
| } |
| break; |
| default: |
| ret = input.skip(ret.ftype); |
| break; |
| } |
| |
| input.readFieldEnd(); |
| } |
| |
| input.readStructEnd(); |
| }; |
| |
| /** |
| * Wite a TApplicationException to the supplied protocol. |
| * @param {object} output - The output protocol to write to. |
| */ |
| Thrift.TApplicationException.prototype.write = function(output) { |
| output.writeStructBegin('TApplicationException'); |
| |
| if (this.message) { |
| output.writeFieldBegin('message', Thrift.Type.STRING, 1); |
| output.writeString(this.getMessage()); |
| output.writeFieldEnd(); |
| } |
| |
| if (this.code) { |
| output.writeFieldBegin('type', Thrift.Type.I32, 2); |
| output.writeI32(this.code); |
| output.writeFieldEnd(); |
| } |
| |
| output.writeFieldStop(); |
| output.writeStructEnd(); |
| }; |
| |
| /** |
| * Returns the application exception code set on the exception. |
| * @readonly |
| * @returns {Thrift.TApplicationExceptionType} exception code |
| */ |
| Thrift.TApplicationException.prototype.getCode = function() { |
| return this.code; |
| }; |
| |
| /** |
| * Constructor Function for the XHR transport. |
| * If you do not specify a url then you must handle XHR operations on |
| * your own. This type can also be constructed using the Transport alias |
| * for backward compatibility. |
| * @constructor |
| * @param {string} [url] - The URL to connect to. |
| * @classdesc The Apache Thrift Transport layer performs byte level I/O |
| * between RPC clients and servers. The JavaScript TXHRTransport object |
| * uses Http[s]/XHR. Target servers must implement the http[s] transport |
| * (see: node.js example server_http.js). |
| * @example |
| * var transport = new Thrift.TXHRTransport("http://localhost:8585"); |
| */ |
| Thrift.Transport = Thrift.TXHRTransport = function(url, options) { |
| this.url = url; |
| this.wpos = 0; |
| this.rpos = 0; |
| this.useCORS = (options && options.useCORS); |
| this.send_buf = ''; |
| this.recv_buf = ''; |
| }; |
| |
| Thrift.TXHRTransport.prototype = { |
| /** |
| * Gets the browser specific XmlHttpRequest Object. |
| * @returns {object} the browser XHR interface object |
| */ |
| getXmlHttpRequestObject: function() { |
| try { return new XMLHttpRequest(); } catch (e1) { } |
| try { return new ActiveXObject('Msxml2.XMLHTTP'); } catch (e2) { } |
| try { return new ActiveXObject('Microsoft.XMLHTTP'); } catch (e3) { } |
| |
| throw "Your browser doesn't support XHR."; |
| }, |
| |
| /** |
| * Sends the current XRH request if the transport was created with a URL |
| * and the async parameter is false. If the transport was not created with |
| * a URL, or the async parameter is True and no callback is provided, or |
| * the URL is an empty string, the current send buffer is returned. |
| * @param {object} async - If true the current send buffer is returned. |
| * @param {object} callback - Optional async completion callback |
| * @returns {undefined|string} Nothing or the current send buffer. |
| * @throws {string} If XHR fails. |
| */ |
| flush: function(async, callback) { |
| var self = this; |
| if ((async && !callback) || this.url === undefined || this.url === '') { |
| return this.send_buf; |
| } |
| |
| var xreq = this.getXmlHttpRequestObject(); |
| |
| if (xreq.overrideMimeType) { |
| xreq.overrideMimeType('application/json'); |
| } |
| |
| if (callback) { |
| //Ignore XHR callbacks until the data arrives, then call the |
| // client's callback |
| xreq.onreadystatechange = |
| (function() { |
| var clientCallback = callback; |
| return function() { |
| if (this.readyState == 4 && this.status == 200) { |
| self.setRecvBuffer(this.responseText); |
| clientCallback(); |
| } |
| }; |
| }()); |
| } |
| |
| xreq.open('POST', this.url, !!async); |
| xreq.send(this.send_buf); |
| if (async && callback) { |
| return; |
| } |
| |
| if (xreq.readyState != 4) { |
| throw 'encountered an unknown ajax ready state: ' + xreq.readyState; |
| } |
| |
| if (xreq.status != 200) { |
| throw 'encountered a unknown request status: ' + xreq.status; |
| } |
| |
| this.recv_buf = xreq.responseText; |
| this.recv_buf_sz = this.recv_buf.length; |
| this.wpos = this.recv_buf.length; |
| this.rpos = 0; |
| }, |
| |
| /** |
| * Creates a jQuery XHR object to be used for a Thrift server call. |
| * @param {object} client - The Thrift Service client object generated by the IDL compiler. |
| * @param {object} postData - The message to send to the server. |
| * @param {function} args - The original call arguments with the success call back at the end. |
| * @param {function} recv_method - The Thrift Service Client receive method for the call. |
| * @returns {object} A new jQuery XHR object. |
| * @throws {string} If the jQuery version is prior to 1.5 or if jQuery is not found. |
| */ |
| jqRequest: function(client, postData, args, recv_method) { |
| if (typeof jQuery === 'undefined' || |
| typeof jQuery.Deferred === 'undefined') { |
| throw 'Thrift.js requires jQuery 1.5+ to use asynchronous requests'; |
| } |
| |
| var thriftTransport = this; |
| |
| var jqXHR = jQuery.ajax({ |
| url: this.url, |
| data: postData, |
| type: 'POST', |
| cache: false, |
| contentType: 'application/json', |
| dataType: 'text thrift', |
| converters: { |
| 'text thrift' : function(responseData) { |
| thriftTransport.setRecvBuffer(responseData); |
| var value = recv_method.call(client); |
| return value; |
| } |
| }, |
| context: client, |
| success: jQuery.makeArray(args).pop() |
| }); |
| |
| return jqXHR; |
| }, |
| |
| /** |
| * Sets the buffer to provide the protocol when deserializing. |
| * @param {string} buf - The buffer to supply the protocol. |
| */ |
| setRecvBuffer: function(buf) { |
| this.recv_buf = buf; |
| this.recv_buf_sz = this.recv_buf.length; |
| this.wpos = this.recv_buf.length; |
| this.rpos = 0; |
| }, |
| |
| /** |
| * Returns true if the transport is open, XHR always returns true. |
| * @readonly |
| * @returns {boolean} Always True. |
| */ |
| isOpen: function() { |
| return true; |
| }, |
| |
| /** |
| * Opens the transport connection, with XHR this is a nop. |
| */ |
| open: function() {}, |
| |
| /** |
| * Closes the transport connection, with XHR this is a nop. |
| */ |
| close: function() {}, |
| |
| /** |
| * Returns the specified number of characters from the response |
| * buffer. |
| * @param {number} len - The number of characters to return. |
| * @returns {string} Characters sent by the server. |
| */ |
| read: function(len) { |
| var avail = this.wpos - this.rpos; |
| |
| if (avail === 0) { |
| return ''; |
| } |
| |
| var give = len; |
| |
| if (avail < len) { |
| give = avail; |
| } |
| |
| var ret = this.read_buf.substr(this.rpos, give); |
| this.rpos += give; |
| |
| //clear buf when complete? |
| return ret; |
| }, |
| |
| /** |
| * Returns the entire response buffer. |
| * @returns {string} Characters sent by the server. |
| */ |
| readAll: function() { |
| return this.recv_buf; |
| }, |
| |
| /** |
| * Sets the send buffer to buf. |
| * @param {string} buf - The buffer to send. |
| */ |
| write: function(buf) { |
| this.send_buf = buf; |
| }, |
| |
| /** |
| * Returns the send buffer. |
| * @readonly |
| * @returns {string} The send buffer. |
| */ |
| getSendBuffer: function() { |
| return this.send_buf; |
| } |
| |
| }; |
| |
| |
| /** |
| * Constructor Function for the WebSocket transport. |
| * @constructor |
| * @param {string} [url] - The URL to connect to. |
| * @classdesc The Apache Thrift Transport layer performs byte level I/O |
| * between RPC clients and servers. The JavaScript TWebSocketTransport object |
| * uses the WebSocket protocol. Target servers must implement WebSocket. |
| * (see: node.js example server_http.js). |
| * @example |
| * var transport = new Thrift.TWebSocketTransport("http://localhost:8585"); |
| */ |
| Thrift.TWebSocketTransport = function(url) { |
| this.__reset(url); |
| }; |
| |
| Thrift.TWebSocketTransport.prototype = { |
| __reset: function(url) { |
| this.url = url; //Where to connect |
| this.socket = null; //The web socket |
| this.callbacks = []; //Pending callbacks |
| this.send_pending = []; //Buffers/Callback pairs waiting to be sent |
| this.send_buf = ''; //Outbound data, immutable until sent |
| this.recv_buf = ''; //Inbound data |
| this.rb_wpos = 0; //Network write position in receive buffer |
| this.rb_rpos = 0; //Client read position in receive buffer |
| }, |
| |
| /** |
| * Sends the current WS request and registers callback. The async |
| * parameter is ignored (WS flush is always async) and the callback |
| * function parameter is required. |
| * @param {object} async - Ignored. |
| * @param {object} callback - The client completion callback. |
| * @returns {undefined|string} Nothing (undefined) |
| */ |
| flush: function(async, callback) { |
| var self = this; |
| if (this.isOpen()) { |
| //Send data and register a callback to invoke the client callback |
| this.socket.send(this.send_buf); |
| this.callbacks.push((function() { |
| var clientCallback = callback; |
| return function(msg) { |
| self.setRecvBuffer(msg); |
| clientCallback(); |
| }; |
| }())); |
| } else { |
| //Queue the send to go out __onOpen |
| this.send_pending.push({ |
| buf: this.send_buf, |
| cb: callback |
| }); |
| } |
| }, |
| |
| __onOpen: function() { |
| var self = this; |
| if (this.send_pending.length > 0) { |
| //If the user made calls before the connection was fully |
| //open, send them now |
| this.send_pending.forEach(function(elem) { |
| this.socket.send(elem.buf); |
| this.callbacks.push((function() { |
| var clientCallback = elem.cb; |
| return function(msg) { |
| self.setRecvBuffer(msg); |
| clientCallback(); |
| }; |
| }())); |
| }); |
| this.send_pending = []; |
| } |
| }, |
| |
| __onClose: function(evt) { |
| this.__reset(this.url); |
| }, |
| |
| __onMessage: function(evt) { |
| if (this.callbacks.length) { |
| this.callbacks.shift()(evt.data); |
| } |
| }, |
| |
| __onError: function(evt) { |
| console.log("Thrift WebSocket Error: " + evt.toString()); |
| this.socket.close(); |
| }, |
| |
| /** |
| * Sets the buffer to use when receiving server responses. |
| * @param {string} buf - The buffer to receive server responses. |
| */ |
| setRecvBuffer: function(buf) { |
| this.recv_buf = buf; |
| this.recv_buf_sz = this.recv_buf.length; |
| this.wpos = this.recv_buf.length; |
| this.rpos = 0; |
| }, |
| |
| /** |
| * Returns true if the transport is open |
| * @readonly |
| * @returns {boolean} |
| */ |
| isOpen: function() { |
| return this.socket && this.socket.readyState == this.socket.OPEN; |
| }, |
| |
| /** |
| * Opens the transport connection |
| */ |
| open: function() { |
| //If OPEN/CONNECTING/CLOSING ignore additional opens |
| if (this.socket && this.socket.readyState != this.socket.CLOSED) { |
| return; |
| } |
| //If there is no socket or the socket is closed: |
| this.socket = new WebSocket(this.url); |
| this.socket.onopen = this.__onOpen.bind(this); |
| this.socket.onmessage = this.__onMessage.bind(this); |
| this.socket.onerror = this.__onError.bind(this); |
| this.socket.onclose = this.__onClose.bind(this); |
| }, |
| |
| /** |
| * Closes the transport connection |
| */ |
| close: function() { |
| this.socket.close(); |
| }, |
| |
| /** |
| * Returns the specified number of characters from the response |
| * buffer. |
| * @param {number} len - The number of characters to return. |
| * @returns {string} Characters sent by the server. |
| */ |
| read: function(len) { |
| var avail = this.wpos - this.rpos; |
| |
| if (avail === 0) { |
| return ''; |
| } |
| |
| var give = len; |
| |
| if (avail < len) { |
| give = avail; |
| } |
| |
| var ret = this.read_buf.substr(this.rpos, give); |
| this.rpos += give; |
| |
| //clear buf when complete? |
| return ret; |
| }, |
| |
| /** |
| * Returns the entire response buffer. |
| * @returns {string} Characters sent by the server. |
| */ |
| readAll: function() { |
| return this.recv_buf; |
| }, |
| |
| /** |
| * Sets the send buffer to buf. |
| * @param {string} buf - The buffer to send. |
| */ |
| write: function(buf) { |
| this.send_buf = buf; |
| }, |
| |
| /** |
| * Returns the send buffer. |
| * @readonly |
| * @returns {string} The send buffer. |
| */ |
| getSendBuffer: function() { |
| return this.send_buf; |
| } |
| |
| }; |
| |
| /** |
| * Initializes a Thrift JSON protocol instance. |
| * @constructor |
| * @param {Thrift.Transport} transport - The transport to serialize to/from. |
| * @classdesc Apache Thrift Protocols perform serialization which enables cross |
| * language RPC. The Protocol type is the JavaScript browser implementation |
| * of the Apache Thrift TJSONProtocol. |
| * @example |
| * var protocol = new Thrift.Protocol(transport); |
| */ |
| Thrift.TJSONProtocol = Thrift.Protocol = function(transport) { |
| this.transport = transport; |
| }; |
| |
| /** |
| * Thrift IDL type Id to string mapping. |
| * @readonly |
| * @see {@link Thrift.Type} |
| */ |
| Thrift.Protocol.Type = {}; |
| Thrift.Protocol.Type[Thrift.Type.BOOL] = '"tf"'; |
| Thrift.Protocol.Type[Thrift.Type.BYTE] = '"i8"'; |
| Thrift.Protocol.Type[Thrift.Type.I16] = '"i16"'; |
| Thrift.Protocol.Type[Thrift.Type.I32] = '"i32"'; |
| Thrift.Protocol.Type[Thrift.Type.I64] = '"i64"'; |
| Thrift.Protocol.Type[Thrift.Type.DOUBLE] = '"dbl"'; |
| Thrift.Protocol.Type[Thrift.Type.STRUCT] = '"rec"'; |
| Thrift.Protocol.Type[Thrift.Type.STRING] = '"str"'; |
| Thrift.Protocol.Type[Thrift.Type.MAP] = '"map"'; |
| Thrift.Protocol.Type[Thrift.Type.LIST] = '"lst"'; |
| Thrift.Protocol.Type[Thrift.Type.SET] = '"set"'; |
| |
| /** |
| * Thrift IDL type string to Id mapping. |
| * @readonly |
| * @see {@link Thrift.Type} |
| */ |
| Thrift.Protocol.RType = {}; |
| Thrift.Protocol.RType.tf = Thrift.Type.BOOL; |
| Thrift.Protocol.RType.i8 = Thrift.Type.BYTE; |
| Thrift.Protocol.RType.i16 = Thrift.Type.I16; |
| Thrift.Protocol.RType.i32 = Thrift.Type.I32; |
| Thrift.Protocol.RType.i64 = Thrift.Type.I64; |
| Thrift.Protocol.RType.dbl = Thrift.Type.DOUBLE; |
| Thrift.Protocol.RType.rec = Thrift.Type.STRUCT; |
| Thrift.Protocol.RType.str = Thrift.Type.STRING; |
| Thrift.Protocol.RType.map = Thrift.Type.MAP; |
| Thrift.Protocol.RType.lst = Thrift.Type.LIST; |
| Thrift.Protocol.RType.set = Thrift.Type.SET; |
| |
| /** |
| * The TJSONProtocol version number. |
| * @readonly |
| * @const {number} Version |
| * @memberof Thrift.Protocol |
| */ |
| Thrift.Protocol.Version = 1; |
| |
| Thrift.Protocol.prototype = { |
| /** |
| * Returns the underlying transport. |
| * @readonly |
| * @returns {Thrift.Transport} The underlying transport. |
| */ |
| getTransport: function() { |
| return this.transport; |
| }, |
| |
| /** |
| * Serializes the beginning of a Thrift RPC message. |
| * @param {string} name - The service method to call. |
| * @param {Thrift.MessageType} messageType - The type of method call. |
| * @param {number} seqid - The sequence number of this call (always 0 in Apache Thrift). |
| */ |
| writeMessageBegin: function(name, messageType, seqid) { |
| this.tstack = []; |
| this.tpos = []; |
| |
| this.tstack.push([Thrift.Protocol.Version, '"' + |
| name + '"', messageType, seqid]); |
| }, |
| |
| /** |
| * Serializes the end of a Thrift RPC message. |
| */ |
| writeMessageEnd: function() { |
| var obj = this.tstack.pop(); |
| |
| this.wobj = this.tstack.pop(); |
| this.wobj.push(obj); |
| |
| this.wbuf = '[' + this.wobj.join(',') + ']'; |
| |
| this.transport.write(this.wbuf); |
| }, |
| |
| |
| /** |
| * Serializes the beginning of a struct. |
| * @param {string} name - The name of the struct. |
| */ |
| writeStructBegin: function(name) { |
| this.tpos.push(this.tstack.length); |
| this.tstack.push({}); |
| }, |
| |
| /** |
| * Serializes the end of a struct. |
| */ |
| writeStructEnd: function() { |
| |
| var p = this.tpos.pop(); |
| var struct = this.tstack[p]; |
| var str = '{'; |
| var first = true; |
| for (var key in struct) { |
| if (first) { |
| first = false; |
| } else { |
| str += ','; |
| } |
| |
| str += key + ':' + struct[key]; |
| } |
| |
| str += '}'; |
| this.tstack[p] = str; |
| }, |
| |
| /** |
| * Serializes the beginning of a struct field. |
| * @param {string} name - The name of the field. |
| * @param {Thrift.Protocol.Type} fieldType - The data type of the field. |
| * @param {number} fieldId - The field's unique identifier. |
| */ |
| writeFieldBegin: function(name, fieldType, fieldId) { |
| this.tpos.push(this.tstack.length); |
| this.tstack.push({ 'fieldId': '"' + |
| fieldId + '"', 'fieldType': Thrift.Protocol.Type[fieldType] |
| }); |
| |
| }, |
| |
| /** |
| * Serializes the end of a field. |
| */ |
| writeFieldEnd: function() { |
| var value = this.tstack.pop(); |
| var fieldInfo = this.tstack.pop(); |
| |
| this.tstack[this.tstack.length - 1][fieldInfo.fieldId] = '{' + |
| fieldInfo.fieldType + ':' + value + '}'; |
| this.tpos.pop(); |
| }, |
| |
| /** |
| * Serializes the end of the set of fields for a struct. |
| */ |
| writeFieldStop: function() { |
| //na |
| }, |
| |
| /** |
| * Serializes the beginning of a map collection. |
| * @param {Thrift.Type} keyType - The data type of the key. |
| * @param {Thrift.Type} valType - The data type of the value. |
| * @param {number} [size] - The number of elements in the map (ignored). |
| */ |
| writeMapBegin: function(keyType, valType, size) { |
| this.tpos.push(this.tstack.length); |
| this.tstack.push([Thrift.Protocol.Type[keyType], |
| Thrift.Protocol.Type[valType], 0]); |
| }, |
| |
| /** |
| * Serializes the end of a map. |
| */ |
| writeMapEnd: function() { |
| var p = this.tpos.pop(); |
| |
| if (p == this.tstack.length) { |
| return; |
| } |
| |
| if ((this.tstack.length - p - 1) % 2 !== 0) { |
| this.tstack.push(''); |
| } |
| |
| var size = (this.tstack.length - p - 1) / 2; |
| |
| this.tstack[p][this.tstack[p].length - 1] = size; |
| |
| var map = '}'; |
| var first = true; |
| while (this.tstack.length > p + 1) { |
| var v = this.tstack.pop(); |
| var k = this.tstack.pop(); |
| if (first) { |
| first = false; |
| } else { |
| map = ',' + map; |
| } |
| |
| if (! isNaN(k)) { k = '"' + k + '"'; } //json "keys" need to be strings |
| map = k + ':' + v + map; |
| } |
| map = '{' + map; |
| |
| this.tstack[p].push(map); |
| this.tstack[p] = '[' + this.tstack[p].join(',') + ']'; |
| }, |
| |
| /** |
| * Serializes the beginning of a list collection. |
| * @param {Thrift.Type} elemType - The data type of the elements. |
| * @param {number} size - The number of elements in the list. |
| */ |
| writeListBegin: function(elemType, size) { |
| this.tpos.push(this.tstack.length); |
| this.tstack.push([Thrift.Protocol.Type[elemType], size]); |
| }, |
| |
| /** |
| * Serializes the end of a list. |
| */ |
| writeListEnd: function() { |
| var p = this.tpos.pop(); |
| |
| while (this.tstack.length > p + 1) { |
| var tmpVal = this.tstack[p + 1]; |
| this.tstack.splice(p + 1, 1); |
| this.tstack[p].push(tmpVal); |
| } |
| |
| this.tstack[p] = '[' + this.tstack[p].join(',') + ']'; |
| }, |
| |
| /** |
| * Serializes the beginning of a set collection. |
| * @param {Thrift.Type} elemType - The data type of the elements. |
| * @param {number} size - The number of elements in the list. |
| */ |
| writeSetBegin: function(elemType, size) { |
| this.tpos.push(this.tstack.length); |
| this.tstack.push([Thrift.Protocol.Type[elemType], size]); |
| }, |
| |
| /** |
| * Serializes the end of a set. |
| */ |
| writeSetEnd: function() { |
| var p = this.tpos.pop(); |
| |
| while (this.tstack.length > p + 1) { |
| var tmpVal = this.tstack[p + 1]; |
| this.tstack.splice(p + 1, 1); |
| this.tstack[p].push(tmpVal); |
| } |
| |
| this.tstack[p] = '[' + this.tstack[p].join(',') + ']'; |
| }, |
| |
| /** Serializes a boolean */ |
| writeBool: function(value) { |
| this.tstack.push(value ? 1 : 0); |
| }, |
| |
| /** Serializes a number */ |
| writeByte: function(i8) { |
| this.tstack.push(i8); |
| }, |
| |
| /** Serializes a number */ |
| writeI16: function(i16) { |
| this.tstack.push(i16); |
| }, |
| |
| /** Serializes a number */ |
| writeI32: function(i32) { |
| this.tstack.push(i32); |
| }, |
| |
| /** Serializes a number */ |
| writeI64: function(i64) { |
| this.tstack.push(i64); |
| }, |
| |
| /** Serializes a number */ |
| writeDouble: function(dbl) { |
| this.tstack.push(dbl); |
| }, |
| |
| /** Serializes a string */ |
| writeString: function(str) { |
| // We do not encode uri components for wire transfer: |
| if (str === null) { |
| this.tstack.push(null); |
| } else { |
| // concat may be slower than building a byte buffer |
| var escapedString = ''; |
| for (var i = 0; i < str.length; i++) { |
| var ch = str.charAt(i); // a single double quote: " |
| if (ch === '\"') { |
| escapedString += '\\\"'; // write out as: \" |
| } else if (ch === '\\') { // a single backslash |
| escapedString += '\\\\'; // write out as double backslash |
| } else if (ch === '\b') { // a single backspace: invisible |
| escapedString += '\\b'; // write out as: \b" |
| } else if (ch === '\f') { // a single formfeed: invisible |
| escapedString += '\\f'; // write out as: \f" |
| } else if (ch === '\n') { // a single newline: invisible |
| escapedString += '\\n'; // write out as: \n" |
| } else if (ch === '\r') { // a single return: invisible |
| escapedString += '\\r'; // write out as: \r" |
| } else if (ch === '\t') { // a single tab: invisible |
| escapedString += '\\t'; // write out as: \t" |
| } else { |
| escapedString += ch; // Else it need not be escaped |
| } |
| } |
| this.tstack.push('"' + escapedString + '"'); |
| } |
| }, |
| |
| /** Serializes a string */ |
| writeBinary: function(str) { |
| this.writeString(str); |
| }, |
| |
| /** |
| @class |
| @name AnonReadMessageBeginReturn |
| @property {string} fname - The name of the service method. |
| @property {Thrift.MessageType} mtype - The type of message call. |
| @property {number} rseqid - The sequence number of the message (0 in Thrift RPC). |
| */ |
| /** |
| * Deserializes the beginning of a message. |
| * @returns {AnonReadMessageBeginReturn} |
| */ |
| readMessageBegin: function() { |
| this.rstack = []; |
| this.rpos = []; |
| |
| if (typeof JSON !== 'undefined' && typeof JSON.parse === 'function') { |
| this.robj = JSON.parse(this.transport.readAll()); |
| } else if (typeof jQuery !== 'undefined') { |
| this.robj = jQuery.parseJSON(this.transport.readAll()); |
| } else { |
| this.robj = eval(this.transport.readAll()); |
| } |
| |
| var r = {}; |
| var version = this.robj.shift(); |
| |
| if (version != Thrift.Protocol.Version) { |
| throw 'Wrong thrift protocol version: ' + version; |
| } |
| |
| r.fname = this.robj.shift(); |
| r.mtype = this.robj.shift(); |
| r.rseqid = this.robj.shift(); |
| |
| |
| //get to the main obj |
| this.rstack.push(this.robj.shift()); |
| |
| return r; |
| }, |
| |
| /** Deserializes the end of a message. */ |
| readMessageEnd: function() { |
| }, |
| |
| /** |
| * Deserializes the beginning of a struct. |
| * @param {string} [name] - The name of the struct (ignored) |
| * @returns {object} - An object with an empty string fname property |
| */ |
| readStructBegin: function(name) { |
| var r = {}; |
| r.fname = ''; |
| |
| //incase this is an array of structs |
| if (this.rstack[this.rstack.length - 1] instanceof Array) { |
| this.rstack.push(this.rstack[this.rstack.length - 1].shift()); |
| } |
| |
| return r; |
| }, |
| |
| /** Deserializes the end of a struct. */ |
| readStructEnd: function() { |
| if (this.rstack[this.rstack.length - 2] instanceof Array) { |
| this.rstack.pop(); |
| } |
| }, |
| |
| /** |
| @class |
| @name AnonReadFieldBeginReturn |
| @property {string} fname - The name of the field (always ''). |
| @property {Thrift.Type} ftype - The data type of the field. |
| @property {number} fid - The unique identifier of the field. |
| */ |
| /** |
| * Deserializes the beginning of a field. |
| * @returns {AnonReadFieldBeginReturn} |
| */ |
| readFieldBegin: function() { |
| var r = {}; |
| |
| var fid = -1; |
| var ftype = Thrift.Type.STOP; |
| |
| //get a fieldId |
| for (var f in (this.rstack[this.rstack.length - 1])) { |
| if (f === null) { |
| continue; |
| } |
| |
| fid = parseInt(f, 10); |
| this.rpos.push(this.rstack.length); |
| |
| var field = this.rstack[this.rstack.length - 1][fid]; |
| |
| //remove so we don't see it again |
| delete this.rstack[this.rstack.length - 1][fid]; |
| |
| this.rstack.push(field); |
| |
| break; |
| } |
| |
| if (fid != -1) { |
| |
| //should only be 1 of these but this is the only |
| //way to match a key |
| for (var i in (this.rstack[this.rstack.length - 1])) { |
| if (Thrift.Protocol.RType[i] === null) { |
| continue; |
| } |
| |
| ftype = Thrift.Protocol.RType[i]; |
| this.rstack[this.rstack.length - 1] = |
| this.rstack[this.rstack.length - 1][i]; |
| } |
| } |
| |
| r.fname = ''; |
| r.ftype = ftype; |
| r.fid = fid; |
| |
| return r; |
| }, |
| |
| /** Deserializes the end of a field. */ |
| readFieldEnd: function() { |
| var pos = this.rpos.pop(); |
| |
| //get back to the right place in the stack |
| while (this.rstack.length > pos) { |
| this.rstack.pop(); |
| } |
| |
| }, |
| |
| /** |
| @class |
| @name AnonReadMapBeginReturn |
| @property {Thrift.Type} ktype - The data type of the key. |
| @property {Thrift.Type} vtype - The data type of the value. |
| @property {number} size - The number of elements in the map. |
| */ |
| /** |
| * Deserializes the beginning of a map. |
| * @returns {AnonReadMapBeginReturn} |
| */ |
| readMapBegin: function() { |
| var map = this.rstack.pop(); |
| |
| var r = {}; |
| r.ktype = Thrift.Protocol.RType[map.shift()]; |
| r.vtype = Thrift.Protocol.RType[map.shift()]; |
| r.size = map.shift(); |
| |
| |
| this.rpos.push(this.rstack.length); |
| this.rstack.push(map.shift()); |
| |
| return r; |
| }, |
| |
| /** Deserializes the end of a map. */ |
| readMapEnd: function() { |
| this.readFieldEnd(); |
| }, |
| |
| /** |
| @class |
| @name AnonReadColBeginReturn |
| @property {Thrift.Type} etype - The data type of the element. |
| @property {number} size - The number of elements in the collection. |
| */ |
| /** |
| * Deserializes the beginning of a list. |
| * @returns {AnonReadColBeginReturn} |
| */ |
| readListBegin: function() { |
| var list = this.rstack[this.rstack.length - 1]; |
| |
| var r = {}; |
| r.etype = Thrift.Protocol.RType[list.shift()]; |
| r.size = list.shift(); |
| |
| this.rpos.push(this.rstack.length); |
| this.rstack.push(list); |
| |
| return r; |
| }, |
| |
| /** Deserializes the end of a list. */ |
| readListEnd: function() { |
| this.readFieldEnd(); |
| }, |
| |
| /** |
| * Deserializes the beginning of a set. |
| * @returns {AnonReadColBeginReturn} |
| */ |
| readSetBegin: function(elemType, size) { |
| return this.readListBegin(elemType, size); |
| }, |
| |
| /** Deserializes the end of a set. */ |
| readSetEnd: function() { |
| return this.readListEnd(); |
| }, |
| |
| /** Returns an object with a value property set to |
| * False unless the next number in the protocol buffer |
| * is 1, in which case teh value property is True */ |
| readBool: function() { |
| var r = this.readI32(); |
| |
| if (r !== null && r.value == '1') { |
| r.value = true; |
| } else { |
| r.value = false; |
| } |
| |
| return r; |
| }, |
| |
| /** Returns the an object with a value property set to the |
| next value found in the protocol buffer */ |
| readByte: function() { |
| return this.readI32(); |
| }, |
| |
| /** Returns the an object with a value property set to the |
| next value found in the protocol buffer */ |
| readI16: function() { |
| return this.readI32(); |
| }, |
| |
| /** Returns the an object with a value property set to the |
| next value found in the protocol buffer */ |
| readI32: function(f) { |
| if (f === undefined) { |
| f = this.rstack[this.rstack.length - 1]; |
| } |
| |
| var r = {}; |
| |
| if (f instanceof Array) { |
| if (f.length === 0) { |
| r.value = undefined; |
| } else { |
| r.value = f.shift(); |
| } |
| } else if (f instanceof Object) { |
| for (var i in f) { |
| if (i === null) { |
| continue; |
| } |
| this.rstack.push(f[i]); |
| delete f[i]; |
| |
| r.value = i; |
| break; |
| } |
| } else { |
| r.value = f; |
| this.rstack.pop(); |
| } |
| |
| return r; |
| }, |
| |
| /** Returns the an object with a value property set to the |
| next value found in the protocol buffer */ |
| readI64: function() { |
| return this.readI32(); |
| }, |
| |
| /** Returns the an object with a value property set to the |
| next value found in the protocol buffer */ |
| readDouble: function() { |
| return this.readI32(); |
| }, |
| |
| /** Returns the an object with a value property set to the |
| next value found in the protocol buffer */ |
| readString: function() { |
| var r = this.readI32(); |
| return r; |
| }, |
| |
| /** Returns the an object with a value property set to the |
| next value found in the protocol buffer */ |
| readBinary: function() { |
| return this.readString(); |
| }, |
| |
| /** |
| * Method to arbitrarily skip over data */ |
| skip: function(type) { |
| var ret, i; |
| switch (type) { |
| case Thrift.Type.STOP: |
| return null; |
| |
| case Thrift.Type.BOOL: |
| return this.readBool(); |
| |
| case Thrift.Type.BYTE: |
| return this.readByte(); |
| |
| case Thrift.Type.I16: |
| return this.readI16(); |
| |
| case Thrift.Type.I32: |
| return this.readI32(); |
| |
| case Thrift.Type.I64: |
| return this.readI64(); |
| |
| case Thrift.Type.DOUBLE: |
| return this.readDouble(); |
| |
| case Thrift.Type.STRING: |
| return this.readString(); |
| |
| case Thrift.Type.STRUCT: |
| this.readStructBegin(); |
| while (true) { |
| ret = this.readFieldBegin(); |
| if (ret.ftype == Thrift.Type.STOP) { |
| break; |
| } |
| this.skip(ret.ftype); |
| this.readFieldEnd(); |
| } |
| this.readStructEnd(); |
| return null; |
| |
| case Thrift.Type.MAP: |
| ret = this.readMapBegin(); |
| for (i = 0; i < ret.size; i++) { |
| if (i > 0) { |
| if (this.rstack.length > this.rpos[this.rpos.length - 1] + 1) { |
| this.rstack.pop(); |
| } |
| } |
| this.skip(ret.ktype); |
| this.skip(ret.vtype); |
| } |
| this.readMapEnd(); |
| return null; |
| |
| case Thrift.Type.SET: |
| ret = this.readSetBegin(); |
| for (i = 0; i < ret.size; i++) { |
| this.skip(ret.etype); |
| } |
| this.readSetEnd(); |
| return null; |
| |
| case Thrift.Type.LIST: |
| ret = this.readListBegin(); |
| for (i = 0; i < ret.size; i++) { |
| this.skip(ret.etype); |
| } |
| this.readListEnd(); |
| return null; |
| } |
| } |
| }; |
| |
| |
| /** |
| * Initializes a MutilplexProtocol Implementation as a Wrapper for Thrift.Protocol |
| * @constructor |
| */ |
| Thrift.MultiplexProtocol = function (srvName, trans, strictRead, strictWrite) { |
| Thrift.Protocol.call(this, trans, strictRead, strictWrite); |
| this.serviceName = srvName; |
| }; |
| Thrift.inherits(Thrift.MultiplexProtocol, Thrift.Protocol, 'multiplexProtocol'); |
| |
| /** Override writeMessageBegin method of prototype*/ |
| Thrift.MultiplexProtocol.prototype.writeMessageBegin = function (name, type, seqid) { |
| |
| if (type === Thrift.MessageType.CALL || type === Thrift.MessageType.ONEWAY) { |
| Thrift.Protocol.prototype.writeMessageBegin.call(this, this.serviceName + ":" + name, type, seqid); |
| } else { |
| Thrift.Protocol.prototype.writeMessageBegin.call(this, name, type, seqid); |
| } |
| }; |
| |
| Thrift.Multiplexer = function () { |
| this.seqid = 0; |
| }; |
| |
| /** Instantiates a multiplexed client for a specific service |
| * @constructor |
| * @param {String} serviceName - The transport to serialize to/from. |
| * @param {Thrift.ServiceClient} SCl - The Service Client Class |
| * @param {Thrift.Transport} transport - Thrift.Transport instance which provides remote host:port |
| * @example |
| * var mp = new Thrift.Multiplexer(); |
| * var transport = new Thrift.Transport("http://localhost:9090/foo.thrift"); |
| * var protocol = new Thrift.Protocol(transport); |
| * var client = mp.createClient('AuthService', AuthServiceClient, transport); |
| */ |
| Thrift.Multiplexer.prototype.createClient = function (serviceName, SCl, transport) { |
| if (SCl.Client) { |
| SCl = SCl.Client; |
| } |
| var self = this; |
| SCl.prototype.new_seqid = function () { |
| self.seqid += 1; |
| return self.seqid; |
| }; |
| var client = new SCl(new Thrift.MultiplexProtocol(serviceName, transport)); |
| |
| return client; |
| }; |
| |
| |
| |