mirror of
https://github.com/fnproject/fn.git
synced 2022-10-28 21:29:17 +03:00
9eaf824398
* add jaeger support, link hot container & req span * adds jaeger support now with FN_JAEGER_URL, there's a simple tutorial in the operating/metrics.md file now and it's pretty easy to get up and running. * links a hot request span to a hot container span. when we change this to sample at a lower ratio we'll need to finagle the hot container span to always sample or something, otherwise we'll hide that info. at least, since we're sampling at 100% for now if this is flipped on, can see freeze/unfreeze etc. if they hit. this is useful for debugging. note that zipkin's exporter does not follow the link at all, hence jaeger... and they're backed by the Cloud Empire now (CNCF) so we'll probably use it anyway. * vendor: add thrift for jaeger
700 lines
23 KiB
TypeScript
700 lines
23 KiB
TypeScript
/*
|
|
* 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.
|
|
*/
|
|
|
|
declare module Thrift {
|
|
/**
|
|
* Thrift JavaScript library version.
|
|
*/
|
|
var Version: string;
|
|
|
|
/**
|
|
* Thrift IDL type string to Id mapping.
|
|
* @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.
|
|
*/
|
|
interface Type {
|
|
'STOP': number;
|
|
'VOID': number;
|
|
'BOOL': number;
|
|
'BYTE': number;
|
|
'I08': number;
|
|
'DOUBLE': number;
|
|
'I16': number;
|
|
'I32': number;
|
|
'I64': number;
|
|
'STRING': number;
|
|
'UTF7': number;
|
|
'STRUCT': number;
|
|
'MAP': number;
|
|
'SET': number;
|
|
'LIST': number;
|
|
'UTF8': number;
|
|
'UTF16': number;
|
|
}
|
|
var Type: Type;
|
|
|
|
/**
|
|
* Thrift RPC message type string to Id mapping.
|
|
* @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.
|
|
*/
|
|
interface MessageType {
|
|
'CALL': number;
|
|
'REPLY': number;
|
|
'EXCEPTION': number;
|
|
'ONEWAY': number;
|
|
}
|
|
var MessageType: MessageType;
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
function objectLength(obj: Object): number;
|
|
|
|
/**
|
|
* Utility function to establish prototype 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.
|
|
*/
|
|
function inherits(constructor: Function, superConstructor: Function, name?: string): void;
|
|
|
|
/**
|
|
* TException is the base class for all Thrift exceptions types.
|
|
*/
|
|
class TException implements Error {
|
|
name: string;
|
|
message: string;
|
|
|
|
/**
|
|
* Initializes a Thrift TException instance.
|
|
* @param {string} message - The TException message (distinct from the Error message).
|
|
*/
|
|
constructor(message: string);
|
|
|
|
/**
|
|
* Returns the message set on the exception.
|
|
* @returns {string} exception message
|
|
*/
|
|
getMessage(): string;
|
|
}
|
|
|
|
/**
|
|
* Thrift Application Exception type string to Id mapping.
|
|
* @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.
|
|
*/
|
|
interface TApplicationExceptionType {
|
|
'UNKNOWN': number;
|
|
'UNKNOWN_METHOD': number;
|
|
'INVALID_MESSAGE_TYPE': number;
|
|
'WRONG_METHOD_NAME': number;
|
|
'BAD_SEQUENCE_ID': number;
|
|
'MISSING_RESULT': number;
|
|
'INTERNAL_ERROR': number;
|
|
'PROTOCOL_ERROR': number;
|
|
'INVALID_TRANSFORM': number;
|
|
'INVALID_PROTOCOL': number;
|
|
'UNSUPPORTED_CLIENT_TYPE': number;
|
|
}
|
|
var TApplicationExceptionType: TApplicationExceptionType;
|
|
|
|
/**
|
|
* TApplicationException is the exception class used to propagate exceptions from an RPC server back to a calling client.
|
|
*/
|
|
class TApplicationException extends TException {
|
|
message: string;
|
|
code: number;
|
|
|
|
/**
|
|
* Initializes a Thrift TApplicationException instance.
|
|
* @param {string} message - The TApplicationException message (distinct from the Error message).
|
|
* @param {Thrift.TApplicationExceptionType} [code] - The TApplicationExceptionType code.
|
|
*/
|
|
constructor(message: string, code?: number);
|
|
|
|
/**
|
|
* Read a TApplicationException from the supplied protocol.
|
|
* @param {object} input - The input protocol to read from.
|
|
*/
|
|
read(input: Object): void;
|
|
|
|
/**
|
|
* Write a TApplicationException to the supplied protocol.
|
|
* @param {object} output - The output protocol to write to.
|
|
*/
|
|
write(output: Object): void;
|
|
|
|
/**
|
|
* Returns the application exception code set on the exception.
|
|
* @returns {Thrift.TApplicationExceptionType} exception code
|
|
*/
|
|
getCode(): number;
|
|
}
|
|
|
|
/**
|
|
* The Apache Thrift Transport layer performs byte level I/O between RPC
|
|
* clients and servers. The JavaScript Transport object type uses Http[s]/XHR and is
|
|
* the sole browser based Thrift transport. Target servers must implement the http[s]
|
|
* transport (see: node.js example server).
|
|
*/
|
|
class TXHRTransport {
|
|
url: string;
|
|
wpos: number;
|
|
rpos: number;
|
|
useCORS: any;
|
|
send_buf: string;
|
|
recv_buf: string;
|
|
|
|
/**
|
|
* 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.
|
|
* @param {string} [url] - The URL to connect to.
|
|
* @param {object} [options] - Options.
|
|
*/
|
|
constructor(url?: string, options?: Object);
|
|
|
|
/**
|
|
* Gets the browser specific XmlHttpRequest Object.
|
|
* @returns {object} the browser XHR interface object
|
|
*/
|
|
getXmlHttpRequestObject(): Object;
|
|
|
|
/**
|
|
* Sends the current XRH request if the transport was created with a URL and
|
|
* the async parameter if false. If the transport was not created with a URL
|
|
* or the async parameter is True 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 {function} callback - Optional async completion callback.
|
|
* @returns {undefined|string} Nothing or the current send buffer.
|
|
*/
|
|
flush(async: any, callback?: Function): string;
|
|
|
|
/**
|
|
* 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 function to call if the request succeeds.
|
|
* @param {function} recv_method - The Thrift Service Client receive method for the call.
|
|
* @returns {object} A new jQuery XHR object.
|
|
*/
|
|
jqRequest(client: Object, postData: any, args: Function, recv_method: Function): Object;
|
|
|
|
/**
|
|
* Sets the buffer to use when receiving server responses.
|
|
* @param {string} buf - The buffer to receive server responses.
|
|
*/
|
|
setRecvBuffer(buf: string): void;
|
|
|
|
/**
|
|
* Returns true if the transport is open, in browser based JavaScript
|
|
* this function always returns true.
|
|
* @returns {boolean} Always True.
|
|
*/
|
|
isOpen(): boolean;
|
|
|
|
/**
|
|
* Opens the transport connection, in browser based JavaScript
|
|
* this function is a nop.
|
|
*/
|
|
open(): void;
|
|
|
|
/**
|
|
* Closes the transport connection, in browser based JavaScript
|
|
* this function is a nop.
|
|
*/
|
|
close(): void;
|
|
|
|
/**
|
|
* 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(len: number): string;
|
|
|
|
/**
|
|
* Returns the entire response buffer.
|
|
* @returns {string} Characters sent by the server.
|
|
*/
|
|
readAll(): string;
|
|
|
|
/**
|
|
* Sets the send buffer to buf.
|
|
* @param {string} buf - The buffer to send.
|
|
*/
|
|
write(buf: string): void;
|
|
|
|
/**
|
|
* Returns the send buffer.
|
|
* @returns {string} The send buffer.
|
|
*/
|
|
getSendBuffer(): string;
|
|
}
|
|
|
|
/**
|
|
* Old alias of the TXHRTransport for backwards compatibility.
|
|
*/
|
|
class Transport extends TXHRTransport { }
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
class TWebSocketTransport {
|
|
url: string; //Where to connect
|
|
socket: any; //The web socket
|
|
callbacks: Function[]; //Pending callbacks
|
|
send_pending: any[]; //Buffers/Callback pairs waiting to be sent
|
|
send_buf: string; //Outbound data, immutable until sent
|
|
recv_buf: string; //Inbound data
|
|
rb_wpos: number; //Network write position in receive buffer
|
|
rb_rpos: number; //Client read position in receive buffer
|
|
|
|
/**
|
|
* Constructor Function for the WebSocket transport.
|
|
* @param {string } [url] - The URL to connect to.
|
|
*/
|
|
constructor(url: string);
|
|
|
|
__reset(url: string): void;
|
|
|
|
/**
|
|
* 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 {function} callback - The client completion callback.
|
|
* @returns {undefined|string} Nothing (undefined)
|
|
*/
|
|
flush(async: any, callback: Function): string;
|
|
|
|
__onOpen(): void;
|
|
|
|
__onClose(): void;
|
|
|
|
__onMessage(): void;
|
|
|
|
__onError(): void;
|
|
|
|
/**
|
|
* Sets the buffer to use when receiving server responses.
|
|
* @param {string} buf - The buffer to receive server responses.
|
|
*/
|
|
setRecvBuffer(buf: string): void;
|
|
|
|
/**
|
|
* Returns true if the transport is open
|
|
* @returns {boolean}
|
|
*/
|
|
isOpen(): boolean;
|
|
|
|
/**
|
|
* Opens the transport connection
|
|
*/
|
|
open(): void;
|
|
|
|
/**
|
|
* Closes the transport connection
|
|
*/
|
|
close(): void;
|
|
|
|
/**
|
|
* 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(len: number): string;
|
|
|
|
/**
|
|
* Returns the entire response buffer.
|
|
* @returns {string} Characters sent by the server.
|
|
*/
|
|
readAll(): string;
|
|
|
|
/**
|
|
* Sets the send buffer to buf.
|
|
* @param {string} buf - The buffer to send.
|
|
*/
|
|
write(buf: string): void;
|
|
|
|
/**
|
|
* Returns the send buffer.
|
|
* @returns {string} The send buffer.
|
|
*/
|
|
getSendBuffer(): string;
|
|
}
|
|
|
|
/**
|
|
* Apache Thrift Protocols perform serialization which enables cross
|
|
* language RPC. The Protocol type is the JavaScript browser implementation
|
|
* of the Apache Thrift TJSONProtocol.
|
|
*/
|
|
class TJSONProtocol {
|
|
transport: Object;
|
|
|
|
/**
|
|
* Thrift IDL type Id to string mapping.
|
|
* The mapping table looks as follows:
|
|
* Thrift.Type.BOOL -> "tf": True/False integer.
|
|
* Thrift.Type.BYTE -> "i8": Signed 8 bit integer.
|
|
* Thrift.Type.I16 -> "i16": Signed 16 bit integer.
|
|
* Thrift.Type.I32 -> "i32": Signed 32 bit integer.
|
|
* Thrift.Type.I64 -> "i64": Signed 64 bit integer.
|
|
* Thrift.Type.DOUBLE -> "dbl": 64 bit IEEE 854 floating point.
|
|
* Thrift.Type.STRUCT -> "rec": A multifield type.
|
|
* Thrift.Type.STRING -> "str": Array of bytes representing a string of characters.
|
|
* Thrift.Type.MAP -> "map": A collection type (map/associative-array/dictionary).
|
|
* Thrift.Type.LIST -> "lst": A collection type (unordered).
|
|
* Thrift.Type.SET -> "set": A collection type (unordered and without repeated values).
|
|
*/
|
|
Type: { [k: number]: string };
|
|
|
|
/**
|
|
* Thrift IDL type string to Id mapping.
|
|
* The mapping table looks as follows:
|
|
* "tf" -> Thrift.Type.BOOL
|
|
* "i8" -> Thrift.Type.BYTE
|
|
* "i16" -> Thrift.Type.I16
|
|
* "i32" -> Thrift.Type.I32
|
|
* "i64" -> Thrift.Type.I64
|
|
* "dbl" -> Thrift.Type.DOUBLE
|
|
* "rec" -> Thrift.Type.STRUCT
|
|
* "str" -> Thrift.Type.STRING
|
|
* "map" -> Thrift.Type.MAP
|
|
* "lst" -> Thrift.Type.LIST
|
|
* "set" -> Thrift.Type.SET
|
|
*/
|
|
RType: { [k: string]: number };
|
|
|
|
/**
|
|
* The TJSONProtocol version number.
|
|
*/
|
|
Version: number;
|
|
|
|
/**
|
|
* Initializes a Thrift JSON protocol instance.
|
|
* @param {Thrift.Transport} transport - The transport to serialize to/from.
|
|
*/
|
|
constructor(transport: Object);
|
|
|
|
/**
|
|
* Returns the underlying transport.
|
|
* @returns {Thrift.Transport} The underlying transport.
|
|
*/
|
|
getTransport(): Object;
|
|
|
|
/**
|
|
* 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(name: string, messageType: number, seqid: number): void;
|
|
|
|
/**
|
|
* Serializes the end of a Thrift RPC message.
|
|
*/
|
|
writeMessageEnd(): void;
|
|
|
|
/**
|
|
* Serializes the beginning of a struct.
|
|
* @param {string} name - The name of the struct.
|
|
*/
|
|
writeStructBegin(name?: string): void;
|
|
|
|
/**
|
|
* Serializes the end of a struct.
|
|
*/
|
|
writeStructEnd(): void;
|
|
|
|
/**
|
|
* 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(name: string, fieldType: number, fieldId: number): void;
|
|
|
|
/**
|
|
* Serializes the end of a field.
|
|
*/
|
|
writeFieldEnd(): void;
|
|
|
|
/**
|
|
* Serializes the end of the set of fields for a struct.
|
|
*/
|
|
writeFieldStop(): void;
|
|
|
|
/**
|
|
* 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(keyType: number, valType: number, size?: number): void;
|
|
|
|
/**
|
|
* Serializes the end of a map.
|
|
*/
|
|
writeMapEnd(): void;
|
|
|
|
/**
|
|
* 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(elemType: number, size: number): void;
|
|
|
|
/**
|
|
* Serializes the end of a list.
|
|
*/
|
|
writeListEnd(): void;
|
|
|
|
/**
|
|
* 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(elemType: number, size: number): void;
|
|
|
|
/**
|
|
* Serializes the end of a set.
|
|
*/
|
|
writeSetEnd(): void;
|
|
|
|
/** Serializes a boolean */
|
|
writeBool(value: boolean): void;
|
|
|
|
/** Serializes a number */
|
|
writeByte(i8: number): void;
|
|
|
|
/** Serializes a number */
|
|
writeI16(i16: number): void;
|
|
|
|
/** Serializes a number */
|
|
writeI32(i32: number): void;
|
|
|
|
/** Serializes a number */
|
|
writeI64(i64: number): void;
|
|
|
|
/** Serializes a number */
|
|
writeDouble(dbl: number): void;
|
|
|
|
/** Serializes a string */
|
|
writeString(str: string): void;
|
|
|
|
/** Serializes a string */
|
|
writeBinary(str: string): void;
|
|
|
|
/**
|
|
@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(): { fname: string; mtype: number; rseqid: number };
|
|
|
|
/** Deserializes the end of a message. */
|
|
readMessageEnd(): void;
|
|
|
|
/**
|
|
* 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(name?: string): { fname: string };
|
|
|
|
/** Deserializes the end of a struct. */
|
|
readStructEnd(): void;
|
|
|
|
/**
|
|
@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(): { fname: string; ftype: number; fid: number };
|
|
|
|
/** Deserializes the end of a field. */
|
|
readFieldEnd(): void;
|
|
|
|
/**
|
|
@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(): { ktype: number; vtype: number; size: number };
|
|
|
|
/** Deserializes the end of a map. */
|
|
readMapEnd(): void;
|
|
|
|
/**
|
|
@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(): { etype: number; size: number };
|
|
|
|
/** Deserializes the end of a list. */
|
|
readListEnd(): void;
|
|
|
|
/**
|
|
* Deserializes the beginning of a set.
|
|
* @param {Thrift.Type} elemType - The data type of the elements (ignored).
|
|
* @param {number} size - The number of elements in the list (ignored).
|
|
* @returns {AnonReadColBeginReturn}
|
|
*/
|
|
readSetBegin(elemType?: number, size?: number): { etype: number; size: number };
|
|
|
|
/** Deserializes the end of a set. */
|
|
readSetEnd(): void;
|
|
|
|
/** Returns an object with a value property set to
|
|
* False unless the next number in the protocol buffer
|
|
* is 1, in which case the value property is True. */
|
|
readBool(): Object;
|
|
|
|
/** Returns an object with a value property set to the
|
|
next value found in the protocol buffer. */
|
|
readByte(): Object;
|
|
|
|
/** Returns an object with a value property set to the
|
|
next value found in the protocol buffer. */
|
|
readI16(): Object;
|
|
|
|
/** Returns an object with a value property set to the
|
|
next value found in the protocol buffer. */
|
|
readI32(f?: any): Object;
|
|
|
|
/** Returns an object with a value property set to the
|
|
next value found in the protocol buffer. */
|
|
readI64(): Object;
|
|
|
|
/** Returns an object with a value property set to the
|
|
next value found in the protocol buffer. */
|
|
readDouble(): Object;
|
|
|
|
/** Returns an object with a value property set to the
|
|
next value found in the protocol buffer. */
|
|
readString(): Object;
|
|
|
|
/** Returns an object with a value property set to the
|
|
next value found in the protocol buffer. */
|
|
readBinary(): Object;
|
|
|
|
/**
|
|
* Method to arbitrarily skip over data (not implemented).
|
|
*/
|
|
skip(type: number): void;
|
|
}
|
|
|
|
/**
|
|
* Old alias of the TXHRTransport for backwards compatibility.
|
|
*/
|
|
class Protocol extends TJSONProtocol { }
|
|
|
|
class MultiplexProtocol extends TJSONProtocol {
|
|
serviceName: string;
|
|
|
|
/**
|
|
* Initializes a MutilplexProtocol Implementation as a Wrapper for Thrift.Protocol.
|
|
* @param {string} srvName
|
|
* @param {Thrift.Transport} trans
|
|
* @param {any} [strictRead]
|
|
* @param {any} [strictWrite]
|
|
*/
|
|
constructor(srvName: string, trans: Object, strictRead?: any, strictWrite?: any);
|
|
|
|
/**
|
|
* Override writeMessageBegin method of prototype
|
|
* 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(name: string, type: number, seqid: number): void;
|
|
}
|
|
|
|
class Multiplexer {
|
|
seqid: number;
|
|
|
|
/**
|
|
* Instantiates a multiplexed client for a specific service.
|
|
* @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.
|
|
*/
|
|
createClient(serviceName: string, SCl: any, transport: Object): any;
|
|
}
|
|
}
|