osquery-extension-manager/lib/gen-nodejs/ExtensionManager.js

Osquery extension manager

//
// Autogenerated by Thrift Compiler (0.14.2)
//
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
//
"use strict";

const thrift = require('thrift');
const Thrift = thrift.Thrift;
const Int64 = require('node-int64');


const Extension = require('./Extension');
const ExtensionClient = Extension.Client;
const ExtensionProcessor = Extension.Processor;
const ttypes = require('./osquery_types');
//HELPER FUNCTIONS AND STRUCTURES

const ExtensionManager_extensions_args = class {
  constructor(args) {
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      input.skip(ftype);
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_extensions_args');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_extensions_result = class {
  constructor(args) {
    this.success = null;
    if (args) {
      if (args.success !== undefined && args.success !== null) {
        this.success = Thrift.copyMap(args.success, [ttypes.InternalExtensionInfo]);
      }
    }
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      const fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid) {
        case 0:
        if (ftype == Thrift.Type.MAP) {
          this.success = {};
          const _rtmp320 = input.readMapBegin();
          const _size19 = _rtmp320.size || 0;
          for (let _i21 = 0; _i21 < _size19; ++_i21) {
            let key22 = null;
            let val23 = null;
            key22 = input.readI64();
            val23 = new ttypes.InternalExtensionInfo();
            val23.read(input);
            this.success[key22] = val23;
          }
          input.readMapEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_extensions_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.MAP, 0);
      output.writeMapBegin(Thrift.Type.I64, Thrift.Type.STRUCT, Thrift.objectLength(this.success));
      for (let kiter24 in this.success) {
        if (this.success.hasOwnProperty(kiter24)) {
          let viter25 = this.success[kiter24];
          output.writeI64(kiter24);
          viter25.write(output);
        }
      }
      output.writeMapEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_options_args = class {
  constructor(args) {
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      input.skip(ftype);
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_options_args');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_options_result = class {
  constructor(args) {
    this.success = null;
    if (args) {
      if (args.success !== undefined && args.success !== null) {
        this.success = Thrift.copyMap(args.success, [ttypes.InternalOptionInfo]);
      }
    }
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      const fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid) {
        case 0:
        if (ftype == Thrift.Type.MAP) {
          this.success = {};
          const _rtmp327 = input.readMapBegin();
          const _size26 = _rtmp327.size || 0;
          for (let _i28 = 0; _i28 < _size26; ++_i28) {
            let key29 = null;
            let val30 = null;
            key29 = input.readString();
            val30 = new ttypes.InternalOptionInfo();
            val30.read(input);
            this.success[key29] = val30;
          }
          input.readMapEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_options_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.MAP, 0);
      output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRUCT, Thrift.objectLength(this.success));
      for (let kiter31 in this.success) {
        if (this.success.hasOwnProperty(kiter31)) {
          let viter32 = this.success[kiter31];
          output.writeString(kiter31);
          viter32.write(output);
        }
      }
      output.writeMapEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_registerExtension_args = class {
  constructor(args) {
    this.info = null;
    this.registry = null;
    if (args) {
      if (args.info !== undefined && args.info !== null) {
        this.info = new ttypes.InternalExtensionInfo(args.info);
      }
      if (args.registry !== undefined && args.registry !== null) {
        this.registry = Thrift.copyMap(args.registry, [null]);
      }
    }
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      const fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid) {
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.info = new ttypes.InternalExtensionInfo();
          this.info.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.MAP) {
          this.registry = {};
          const _rtmp334 = input.readMapBegin();
          const _size33 = _rtmp334.size || 0;
          for (let _i35 = 0; _i35 < _size33; ++_i35) {
            let key36 = null;
            let val37 = null;
            key36 = input.readString();
            val37 = {};
            const _rtmp339 = input.readMapBegin();
            const _size38 = _rtmp339.size || 0;
            for (let _i40 = 0; _i40 < _size38; ++_i40) {
              let key41 = null;
              let val42 = null;
              key41 = input.readString();
              val42 = [];
              const _rtmp344 = input.readListBegin();
              const _size43 = _rtmp344.size || 0;
              for (let _i45 = 0; _i45 < _size43; ++_i45) {
                let elem46 = null;
                elem46 = {};
                const _rtmp348 = input.readMapBegin();
                const _size47 = _rtmp348.size || 0;
                for (let _i49 = 0; _i49 < _size47; ++_i49) {
                  let key50 = null;
                  let val51 = null;
                  key50 = input.readString();
                  val51 = input.readString();
                  elem46[key50] = val51;
                }
                input.readMapEnd();
                val42.push(elem46);
              }
              input.readListEnd();
              val37[key41] = val42;
            }
            input.readMapEnd();
            this.registry[key36] = val37;
          }
          input.readMapEnd();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_registerExtension_args');
    if (this.info !== null && this.info !== undefined) {
      output.writeFieldBegin('info', Thrift.Type.STRUCT, 1);
      this.info.write(output);
      output.writeFieldEnd();
    }
    if (this.registry !== null && this.registry !== undefined) {
      output.writeFieldBegin('registry', Thrift.Type.MAP, 2);
      output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.MAP, Thrift.objectLength(this.registry));
      for (let kiter52 in this.registry) {
        if (this.registry.hasOwnProperty(kiter52)) {
          let viter53 = this.registry[kiter52];
          output.writeString(kiter52);
          output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.LIST, Thrift.objectLength(viter53));
          for (let kiter54 in viter53) {
            if (viter53.hasOwnProperty(kiter54)) {
              let viter55 = viter53[kiter54];
              output.writeString(kiter54);
              output.writeListBegin(Thrift.Type.MAP, viter55.length);
              for (let iter56 in viter55) {
                if (viter55.hasOwnProperty(iter56)) {
                  iter56 = viter55[iter56];
                  output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRING, Thrift.objectLength(iter56));
                  for (let kiter57 in iter56) {
                    if (iter56.hasOwnProperty(kiter57)) {
                      let viter58 = iter56[kiter57];
                      output.writeString(kiter57);
                      output.writeString(viter58);
                    }
                  }
                  output.writeMapEnd();
                }
              }
              output.writeListEnd();
            }
          }
          output.writeMapEnd();
        }
      }
      output.writeMapEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_registerExtension_result = class {
  constructor(args) {
    this.success = null;
    if (args) {
      if (args.success !== undefined && args.success !== null) {
        this.success = new ttypes.ExtensionStatus(args.success);
      }
    }
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      const fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid) {
        case 0:
        if (ftype == Thrift.Type.STRUCT) {
          this.success = new ttypes.ExtensionStatus();
          this.success.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_registerExtension_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
      this.success.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_deregisterExtension_args = class {
  constructor(args) {
    this.uuid = null;
    if (args) {
      if (args.uuid !== undefined && args.uuid !== null) {
        this.uuid = args.uuid;
      }
    }
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      const fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid) {
        case 1:
        if (ftype == Thrift.Type.I64) {
          this.uuid = input.readI64();
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_deregisterExtension_args');
    if (this.uuid !== null && this.uuid !== undefined) {
      output.writeFieldBegin('uuid', Thrift.Type.I64, 1);
      output.writeI64(this.uuid);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_deregisterExtension_result = class {
  constructor(args) {
    this.success = null;
    if (args) {
      if (args.success !== undefined && args.success !== null) {
        this.success = new ttypes.ExtensionStatus(args.success);
      }
    }
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      const fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid) {
        case 0:
        if (ftype == Thrift.Type.STRUCT) {
          this.success = new ttypes.ExtensionStatus();
          this.success.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_deregisterExtension_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
      this.success.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_query_args = class {
  constructor(args) {
    this.sql = null;
    if (args) {
      if (args.sql !== undefined && args.sql !== null) {
        this.sql = args.sql;
      }
    }
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      const fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid) {
        case 1:
        if (ftype == Thrift.Type.STRING) {
          this.sql = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_query_args');
    if (this.sql !== null && this.sql !== undefined) {
      output.writeFieldBegin('sql', Thrift.Type.STRING, 1);
      output.writeString(this.sql);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_query_result = class {
  constructor(args) {
    this.success = null;
    if (args) {
      if (args.success !== undefined && args.success !== null) {
        this.success = new ttypes.ExtensionResponse(args.success);
      }
    }
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      const fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid) {
        case 0:
        if (ftype == Thrift.Type.STRUCT) {
          this.success = new ttypes.ExtensionResponse();
          this.success.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_query_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
      this.success.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_getQueryColumns_args = class {
  constructor(args) {
    this.sql = null;
    if (args) {
      if (args.sql !== undefined && args.sql !== null) {
        this.sql = args.sql;
      }
    }
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      const fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid) {
        case 1:
        if (ftype == Thrift.Type.STRING) {
          this.sql = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_getQueryColumns_args');
    if (this.sql !== null && this.sql !== undefined) {
      output.writeFieldBegin('sql', Thrift.Type.STRING, 1);
      output.writeString(this.sql);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_getQueryColumns_result = class {
  constructor(args) {
    this.success = null;
    if (args) {
      if (args.success !== undefined && args.success !== null) {
        this.success = new ttypes.ExtensionResponse(args.success);
      }
    }
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      const fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid) {
        case 0:
        if (ftype == Thrift.Type.STRUCT) {
          this.success = new ttypes.ExtensionResponse();
          this.success.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_getQueryColumns_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
      this.success.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_streamEvents_args = class {
  constructor(args) {
    this.name = null;
    this.events = null;
    if (args) {
      if (args.name !== undefined && args.name !== null) {
        this.name = args.name;
      }
      if (args.events !== undefined && args.events !== null) {
        this.events = Thrift.copyList(args.events, [Thrift.copyMap, null]);
      }
    }
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      const fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid) {
        case 1:
        if (ftype == Thrift.Type.STRING) {
          this.name = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.LIST) {
          this.events = [];
          const _rtmp360 = input.readListBegin();
          const _size59 = _rtmp360.size || 0;
          for (let _i61 = 0; _i61 < _size59; ++_i61) {
            let elem62 = null;
            elem62 = {};
            const _rtmp364 = input.readMapBegin();
            const _size63 = _rtmp364.size || 0;
            for (let _i65 = 0; _i65 < _size63; ++_i65) {
              let key66 = null;
              let val67 = null;
              key66 = input.readString();
              val67 = input.readString();
              elem62[key66] = val67;
            }
            input.readMapEnd();
            this.events.push(elem62);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_streamEvents_args');
    if (this.name !== null && this.name !== undefined) {
      output.writeFieldBegin('name', Thrift.Type.STRING, 1);
      output.writeString(this.name);
      output.writeFieldEnd();
    }
    if (this.events !== null && this.events !== undefined) {
      output.writeFieldBegin('events', Thrift.Type.LIST, 2);
      output.writeListBegin(Thrift.Type.MAP, this.events.length);
      for (let iter68 in this.events) {
        if (this.events.hasOwnProperty(iter68)) {
          iter68 = this.events[iter68];
          output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRING, Thrift.objectLength(iter68));
          for (let kiter69 in iter68) {
            if (iter68.hasOwnProperty(kiter69)) {
              let viter70 = iter68[kiter69];
              output.writeString(kiter69);
              output.writeString(viter70);
            }
          }
          output.writeMapEnd();
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_streamEvents_result = class {
  constructor(args) {
    this.success = null;
    if (args) {
      if (args.success !== undefined && args.success !== null) {
        this.success = new ttypes.ExtensionStatus(args.success);
      }
    }
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      const fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid) {
        case 0:
        if (ftype == Thrift.Type.STRUCT) {
          this.success = new ttypes.ExtensionStatus();
          this.success.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_streamEvents_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
      this.success.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_getNodeKey_args = class {
  constructor(args) {
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      input.skip(ftype);
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_getNodeKey_args');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManager_getNodeKey_result = class {
  constructor(args) {
    this.success = null;
    if (args) {
      if (args.success !== undefined && args.success !== null) {
        this.success = args.success;
      }
    }
  }

  read (input) {
    input.readStructBegin();
    while (true) {
      const ret = input.readFieldBegin();
      const ftype = ret.ftype;
      const fid = ret.fid;
      if (ftype == Thrift.Type.STOP) {
        break;
      }
      switch (fid) {
        case 0:
        if (ftype == Thrift.Type.STRING) {
          this.success = input.readString();
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  }

  write (output) {
    output.writeStructBegin('ExtensionManager_getNodeKey_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRING, 0);
      output.writeString(this.success);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  }

};
const ExtensionManagerClient = exports.Client = class ExtensionManagerClient extends ExtensionClient {
  constructor(output, pClass) {
    super(output, pClass);
    this.output = output;
    this.pClass = pClass;
    this._seqid = 0;
    this._reqs = {};
  }
  seqid () { return this._seqid; }
  new_seqid () { return this._seqid += 1; }

  extensions () {
    this._seqid = this.new_seqid();
    const self = this;
    return new Promise((resolve, reject) => {
      self._reqs[self.seqid()] = (error, result) => {
        return error ? reject(error) : resolve(result);
      };
      self.send_extensions();
    });
  }

  send_extensions () {
    const output = new this.pClass(this.output);
    const args = new ExtensionManager_extensions_args();
    try {
      output.writeMessageBegin('extensions', Thrift.MessageType.CALL, this.seqid());
      args.write(output);
      output.writeMessageEnd();
      return this.output.flush();
    }
    catch (e) {
      delete this._reqs[this.seqid()];
      if (typeof output.reset === 'function') {
        output.reset();
      }
      throw e;
    }
  }

  recv_extensions (input, mtype, rseqid) {
    const callback = this._reqs[rseqid] || function() {};
    delete this._reqs[rseqid];
    if (mtype == Thrift.MessageType.EXCEPTION) {
      const x = new Thrift.TApplicationException();
      x.read(input);
      input.readMessageEnd();
      return callback(x);
    }
    const result = new ExtensionManager_extensions_result();
    result.read(input);
    input.readMessageEnd();

    if (null !== result.success) {
      return callback(null, result.success);
    }
    return callback('extensions failed: unknown result');
  }

  options () {
    this._seqid = this.new_seqid();
    const self = this;
    return new Promise((resolve, reject) => {
      self._reqs[self.seqid()] = (error, result) => {
        return error ? reject(error) : resolve(result);
      };
      self.send_options();
    });
  }

  send_options () {
    const output = new this.pClass(this.output);
    const args = new ExtensionManager_options_args();
    try {
      output.writeMessageBegin('options', Thrift.MessageType.CALL, this.seqid());
      args.write(output);
      output.writeMessageEnd();
      return this.output.flush();
    }
    catch (e) {
      delete this._reqs[this.seqid()];
      if (typeof output.reset === 'function') {
        output.reset();
      }
      throw e;
    }
  }

  recv_options (input, mtype, rseqid) {
    const callback = this._reqs[rseqid] || function() {};
    delete this._reqs[rseqid];
    if (mtype == Thrift.MessageType.EXCEPTION) {
      const x = new Thrift.TApplicationException();
      x.read(input);
      input.readMessageEnd();
      return callback(x);
    }
    const result = new ExtensionManager_options_result();
    result.read(input);
    input.readMessageEnd();

    if (null !== result.success) {
      return callback(null, result.success);
    }
    return callback('options failed: unknown result');
  }

  registerExtension (info, registry) {
    this._seqid = this.new_seqid();
    const self = this;
    return new Promise((resolve, reject) => {
      self._reqs[self.seqid()] = (error, result) => {
        return error ? reject(error) : resolve(result);
      };
      self.send_registerExtension(info, registry);
    });
  }

  send_registerExtension (info, registry) {
    const output = new this.pClass(this.output);
    const params = {
      info: info,
      registry: registry
    };
    const args = new ExtensionManager_registerExtension_args(params);
    try {
      output.writeMessageBegin('registerExtension', Thrift.MessageType.CALL, this.seqid());
      args.write(output);
      output.writeMessageEnd();
      return this.output.flush();
    }
    catch (e) {
      delete this._reqs[this.seqid()];
      if (typeof output.reset === 'function') {
        output.reset();
      }
      throw e;
    }
  }

  recv_registerExtension (input, mtype, rseqid) {
    const callback = this._reqs[rseqid] || function() {};
    delete this._reqs[rseqid];
    if (mtype == Thrift.MessageType.EXCEPTION) {
      const x = new Thrift.TApplicationException();
      x.read(input);
      input.readMessageEnd();
      return callback(x);
    }
    const result = new ExtensionManager_registerExtension_result();
    result.read(input);
    input.readMessageEnd();

    if (null !== result.success) {
      return callback(null, result.success);
    }
    return callback('registerExtension failed: unknown result');
  }

  deregisterExtension (uuid) {
    this._seqid = this.new_seqid();
    const self = this;
    return new Promise((resolve, reject) => {
      self._reqs[self.seqid()] = (error, result) => {
        return error ? reject(error) : resolve(result);
      };
      self.send_deregisterExtension(uuid);
    });
  }

  send_deregisterExtension (uuid) {
    const output = new this.pClass(this.output);
    const params = {
      uuid: uuid
    };
    const args = new ExtensionManager_deregisterExtension_args(params);
    try {
      output.writeMessageBegin('deregisterExtension', Thrift.MessageType.CALL, this.seqid());
      args.write(output);
      output.writeMessageEnd();
      return this.output.flush();
    }
    catch (e) {
      delete this._reqs[this.seqid()];
      if (typeof output.reset === 'function') {
        output.reset();
      }
      throw e;
    }
  }

  recv_deregisterExtension (input, mtype, rseqid) {
    const callback = this._reqs[rseqid] || function() {};
    delete this._reqs[rseqid];
    if (mtype == Thrift.MessageType.EXCEPTION) {
      const x = new Thrift.TApplicationException();
      x.read(input);
      input.readMessageEnd();
      return callback(x);
    }
    const result = new ExtensionManager_deregisterExtension_result();
    result.read(input);
    input.readMessageEnd();

    if (null !== result.success) {
      return callback(null, result.success);
    }
    return callback('deregisterExtension failed: unknown result');
  }

  query (sql) {
    this._seqid = this.new_seqid();
    const self = this;
    return new Promise((resolve, reject) => {
      self._reqs[self.seqid()] = (error, result) => {
        return error ? reject(error) : resolve(result);
      };
      self.send_query(sql);
    });
  }

  send_query (sql) {
    const output = new this.pClass(this.output);
    const params = {
      sql: sql
    };
    const args = new ExtensionManager_query_args(params);
    try {
      output.writeMessageBegin('query', Thrift.MessageType.CALL, this.seqid());
      args.write(output);
      output.writeMessageEnd();
      return this.output.flush();
    }
    catch (e) {
      delete this._reqs[this.seqid()];
      if (typeof output.reset === 'function') {
        output.reset();
      }
      throw e;
    }
  }

  recv_query (input, mtype, rseqid) {
    const callback = this._reqs[rseqid] || function() {};
    delete this._reqs[rseqid];
    if (mtype == Thrift.MessageType.EXCEPTION) {
      const x = new Thrift.TApplicationException();
      x.read(input);
      input.readMessageEnd();
      return callback(x);
    }
    const result = new ExtensionManager_query_result();
    result.read(input);
    input.readMessageEnd();

    if (null !== result.success) {
      return callback(null, result.success);
    }
    return callback('query failed: unknown result');
  }

  getQueryColumns (sql) {
    this._seqid = this.new_seqid();
    const self = this;
    return new Promise((resolve, reject) => {
      self._reqs[self.seqid()] = (error, result) => {
        return error ? reject(error) : resolve(result);
      };
      self.send_getQueryColumns(sql);
    });
  }

  send_getQueryColumns (sql) {
    const output = new this.pClass(this.output);
    const params = {
      sql: sql
    };
    const args = new ExtensionManager_getQueryColumns_args(params);
    try {
      output.writeMessageBegin('getQueryColumns', Thrift.MessageType.CALL, this.seqid());
      args.write(output);
      output.writeMessageEnd();
      return this.output.flush();
    }
    catch (e) {
      delete this._reqs[this.seqid()];
      if (typeof output.reset === 'function') {
        output.reset();
      }
      throw e;
    }
  }

  recv_getQueryColumns (input, mtype, rseqid) {
    const callback = this._reqs[rseqid] || function() {};
    delete this._reqs[rseqid];
    if (mtype == Thrift.MessageType.EXCEPTION) {
      const x = new Thrift.TApplicationException();
      x.read(input);
      input.readMessageEnd();
      return callback(x);
    }
    const result = new ExtensionManager_getQueryColumns_result();
    result.read(input);
    input.readMessageEnd();

    if (null !== result.success) {
      return callback(null, result.success);
    }
    return callback('getQueryColumns failed: unknown result');
  }

  streamEvents (name, events) {
    this._seqid = this.new_seqid();
    const self = this;
    return new Promise((resolve, reject) => {
      self._reqs[self.seqid()] = (error, result) => {
        return error ? reject(error) : resolve(result);
      };
      self.send_streamEvents(name, events);
    });
  }

  send_streamEvents (name, events) {
    const output = new this.pClass(this.output);
    const params = {
      name: name,
      events: events
    };
    const args = new ExtensionManager_streamEvents_args(params);
    try {
      output.writeMessageBegin('streamEvents', Thrift.MessageType.CALL, this.seqid());
      args.write(output);
      output.writeMessageEnd();
      return this.output.flush();
    }
    catch (e) {
      delete this._reqs[this.seqid()];
      if (typeof output.reset === 'function') {
        output.reset();
      }
      throw e;
    }
  }

  recv_streamEvents (input, mtype, rseqid) {
    const callback = this._reqs[rseqid] || function() {};
    delete this._reqs[rseqid];
    if (mtype == Thrift.MessageType.EXCEPTION) {
      const x = new Thrift.TApplicationException();
      x.read(input);
      input.readMessageEnd();
      return callback(x);
    }
    const result = new ExtensionManager_streamEvents_result();
    result.read(input);
    input.readMessageEnd();

    if (null !== result.success) {
      return callback(null, result.success);
    }
    return callback('streamEvents failed: unknown result');
  }

  getNodeKey () {
    this._seqid = this.new_seqid();
    const self = this;
    return new Promise((resolve, reject) => {
      self._reqs[self.seqid()] = (error, result) => {
        return error ? reject(error) : resolve(result);
      };
      self.send_getNodeKey();
    });
  }

  send_getNodeKey () {
    const output = new this.pClass(this.output);
    const args = new ExtensionManager_getNodeKey_args();
    try {
      output.writeMessageBegin('getNodeKey', Thrift.MessageType.CALL, this.seqid());
      args.write(output);
      output.writeMessageEnd();
      return this.output.flush();
    }
    catch (e) {
      delete this._reqs[this.seqid()];
      if (typeof output.reset === 'function') {
        output.reset();
      }
      throw e;
    }
  }

  recv_getNodeKey (input, mtype, rseqid) {
    const callback = this._reqs[rseqid] || function() {};
    delete this._reqs[rseqid];
    if (mtype == Thrift.MessageType.EXCEPTION) {
      const x = new Thrift.TApplicationException();
      x.read(input);
      input.readMessageEnd();
      return callback(x);
    }
    const result = new ExtensionManager_getNodeKey_result();
    result.read(input);
    input.readMessageEnd();

    if (null !== result.success) {
      return callback(null, result.success);
    }
    return callback('getNodeKey failed: unknown result');
  }
};
const ExtensionManagerProcessor = exports.Processor = class ExtensionManagerProcessor extends ExtensionProcessor {
  constructor(handler) {
    super(handler);
    this._handler = handler;
  }
  process (input, output) {
    const r = input.readMessageBegin();
    if (this['process_' + r.fname]) {
      return this['process_' + r.fname].call(this, r.rseqid, input, output);
    } else {
      input.skip(Thrift.Type.STRUCT);
      input.readMessageEnd();
      const x = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN_METHOD, 'Unknown function ' + r.fname);
      output.writeMessageBegin(r.fname, Thrift.MessageType.EXCEPTION, r.rseqid);
      x.write(output);
      output.writeMessageEnd();
      output.flush();
    }
  }
  process_extensions (seqid, input, output) {
    const args = new ExtensionManager_extensions_args();
    args.read(input);
    input.readMessageEnd();
    if (this._handler.extensions.length === 0) {
      Promise.resolve(this._handler.extensions.bind(this._handler)(
      )).then(result => {
        const result_obj = new ExtensionManager_extensions_result({success: result});
        output.writeMessageBegin("extensions", Thrift.MessageType.REPLY, seqid);
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      }).catch(err => {
        let result;
        result = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
        output.writeMessageBegin("extensions", Thrift.MessageType.EXCEPTION, seqid);
        result.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    } else {
      this._handler.extensions((err, result) => {
        let result_obj;
        if ((err === null || typeof err === 'undefined')) {
          result_obj = new ExtensionManager_extensions_result((err !== null || typeof err === 'undefined') ? err : {success: result});
          output.writeMessageBegin("extensions", Thrift.MessageType.REPLY, seqid);
        } else {
          result_obj = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
          output.writeMessageBegin("extensions", Thrift.MessageType.EXCEPTION, seqid);
        }
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    }
  }
  process_options (seqid, input, output) {
    const args = new ExtensionManager_options_args();
    args.read(input);
    input.readMessageEnd();
    if (this._handler.options.length === 0) {
      Promise.resolve(this._handler.options.bind(this._handler)(
      )).then(result => {
        const result_obj = new ExtensionManager_options_result({success: result});
        output.writeMessageBegin("options", Thrift.MessageType.REPLY, seqid);
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      }).catch(err => {
        let result;
        result = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
        output.writeMessageBegin("options", Thrift.MessageType.EXCEPTION, seqid);
        result.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    } else {
      this._handler.options((err, result) => {
        let result_obj;
        if ((err === null || typeof err === 'undefined')) {
          result_obj = new ExtensionManager_options_result((err !== null || typeof err === 'undefined') ? err : {success: result});
          output.writeMessageBegin("options", Thrift.MessageType.REPLY, seqid);
        } else {
          result_obj = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
          output.writeMessageBegin("options", Thrift.MessageType.EXCEPTION, seqid);
        }
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    }
  }
  process_registerExtension (seqid, input, output) {
    const args = new ExtensionManager_registerExtension_args();
    args.read(input);
    input.readMessageEnd();
    if (this._handler.registerExtension.length === 2) {
      Promise.resolve(this._handler.registerExtension.bind(this._handler)(
        args.info,
        args.registry
      )).then(result => {
        const result_obj = new ExtensionManager_registerExtension_result({success: result});
        output.writeMessageBegin("registerExtension", Thrift.MessageType.REPLY, seqid);
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      }).catch(err => {
        let result;
        result = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
        output.writeMessageBegin("registerExtension", Thrift.MessageType.EXCEPTION, seqid);
        result.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    } else {
      this._handler.registerExtension(args.info, args.registry, (err, result) => {
        let result_obj;
        if ((err === null || typeof err === 'undefined')) {
          result_obj = new ExtensionManager_registerExtension_result((err !== null || typeof err === 'undefined') ? err : {success: result});
          output.writeMessageBegin("registerExtension", Thrift.MessageType.REPLY, seqid);
        } else {
          result_obj = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
          output.writeMessageBegin("registerExtension", Thrift.MessageType.EXCEPTION, seqid);
        }
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    }
  }
  process_deregisterExtension (seqid, input, output) {
    const args = new ExtensionManager_deregisterExtension_args();
    args.read(input);
    input.readMessageEnd();
    if (this._handler.deregisterExtension.length === 1) {
      Promise.resolve(this._handler.deregisterExtension.bind(this._handler)(
        args.uuid
      )).then(result => {
        const result_obj = new ExtensionManager_deregisterExtension_result({success: result});
        output.writeMessageBegin("deregisterExtension", Thrift.MessageType.REPLY, seqid);
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      }).catch(err => {
        let result;
        result = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
        output.writeMessageBegin("deregisterExtension", Thrift.MessageType.EXCEPTION, seqid);
        result.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    } else {
      this._handler.deregisterExtension(args.uuid, (err, result) => {
        let result_obj;
        if ((err === null || typeof err === 'undefined')) {
          result_obj = new ExtensionManager_deregisterExtension_result((err !== null || typeof err === 'undefined') ? err : {success: result});
          output.writeMessageBegin("deregisterExtension", Thrift.MessageType.REPLY, seqid);
        } else {
          result_obj = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
          output.writeMessageBegin("deregisterExtension", Thrift.MessageType.EXCEPTION, seqid);
        }
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    }
  }
  process_query (seqid, input, output) {
    const args = new ExtensionManager_query_args();
    args.read(input);
    input.readMessageEnd();
    if (this._handler.query.length === 1) {
      Promise.resolve(this._handler.query.bind(this._handler)(
        args.sql
      )).then(result => {
        const result_obj = new ExtensionManager_query_result({success: result});
        output.writeMessageBegin("query", Thrift.MessageType.REPLY, seqid);
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      }).catch(err => {
        let result;
        result = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
        output.writeMessageBegin("query", Thrift.MessageType.EXCEPTION, seqid);
        result.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    } else {
      this._handler.query(args.sql, (err, result) => {
        let result_obj;
        if ((err === null || typeof err === 'undefined')) {
          result_obj = new ExtensionManager_query_result((err !== null || typeof err === 'undefined') ? err : {success: result});
          output.writeMessageBegin("query", Thrift.MessageType.REPLY, seqid);
        } else {
          result_obj = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
          output.writeMessageBegin("query", Thrift.MessageType.EXCEPTION, seqid);
        }
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    }
  }
  process_getQueryColumns (seqid, input, output) {
    const args = new ExtensionManager_getQueryColumns_args();
    args.read(input);
    input.readMessageEnd();
    if (this._handler.getQueryColumns.length === 1) {
      Promise.resolve(this._handler.getQueryColumns.bind(this._handler)(
        args.sql
      )).then(result => {
        const result_obj = new ExtensionManager_getQueryColumns_result({success: result});
        output.writeMessageBegin("getQueryColumns", Thrift.MessageType.REPLY, seqid);
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      }).catch(err => {
        let result;
        result = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
        output.writeMessageBegin("getQueryColumns", Thrift.MessageType.EXCEPTION, seqid);
        result.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    } else {
      this._handler.getQueryColumns(args.sql, (err, result) => {
        let result_obj;
        if ((err === null || typeof err === 'undefined')) {
          result_obj = new ExtensionManager_getQueryColumns_result((err !== null || typeof err === 'undefined') ? err : {success: result});
          output.writeMessageBegin("getQueryColumns", Thrift.MessageType.REPLY, seqid);
        } else {
          result_obj = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
          output.writeMessageBegin("getQueryColumns", Thrift.MessageType.EXCEPTION, seqid);
        }
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    }
  }
  process_streamEvents (seqid, input, output) {
    const args = new ExtensionManager_streamEvents_args();
    args.read(input);
    input.readMessageEnd();
    if (this._handler.streamEvents.length === 2) {
      Promise.resolve(this._handler.streamEvents.bind(this._handler)(
        args.name,
        args.events
      )).then(result => {
        const result_obj = new ExtensionManager_streamEvents_result({success: result});
        output.writeMessageBegin("streamEvents", Thrift.MessageType.REPLY, seqid);
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      }).catch(err => {
        let result;
        result = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
        output.writeMessageBegin("streamEvents", Thrift.MessageType.EXCEPTION, seqid);
        result.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    } else {
      this._handler.streamEvents(args.name, args.events, (err, result) => {
        let result_obj;
        if ((err === null || typeof err === 'undefined')) {
          result_obj = new ExtensionManager_streamEvents_result((err !== null || typeof err === 'undefined') ? err : {success: result});
          output.writeMessageBegin("streamEvents", Thrift.MessageType.REPLY, seqid);
        } else {
          result_obj = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
          output.writeMessageBegin("streamEvents", Thrift.MessageType.EXCEPTION, seqid);
        }
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    }
  }
  process_getNodeKey (seqid, input, output) {
    const args = new ExtensionManager_getNodeKey_args();
    args.read(input);
    input.readMessageEnd();
    if (this._handler.getNodeKey.length === 0) {
      Promise.resolve(this._handler.getNodeKey.bind(this._handler)(
      )).then(result => {
        const result_obj = new ExtensionManager_getNodeKey_result({success: result});
        output.writeMessageBegin("getNodeKey", Thrift.MessageType.REPLY, seqid);
        result_obj.write(output);
        output.writeMessageEnd();
        output.flush();
      }).catch(err => {
        let result;
        result = new Thrift.TApplicationException(Thrift.TApplicationExceptionType.UNKNOWN, err.message);
        output.writeMessageBegin("getNodeKey", Thrift.MessageType.EXCEPTION, seqid);
        result.write(output);
        output.writeMessageEnd();
        output.flush();
      });
    } else {
      this._handler.getNodeKey((err, result) => {
        let result_obj;
        if ((err === null || typeof err === 'undefined')) {
          result_obj = new ExtensionManager_getNodeKey_result((err !== null || typeof err === 'undefined') ? err : {success: result});
          output.writeMessageBegin("getNodeKey", Thrift.MessageType.REPLY, seqid);
        } else {
          result_obj = new Thrift.TApplicationException(Thrift.TApplication