node-firebird 2.3.1 → 2.3.3

package/poc/node_modules/node-firebird/lib/wire/service.js

@@ -0,0 +1,1058 @@
+const Events = require('events');
+const stream = require('stream');
+const Const = require('./const');
+const {BlrReader} = require('./serialize');
+const {doError} = require('../callback');
+
+/***************************************
+ *
+ *   Helper Functions and Constants
+ *
+ ***************************************/
+
+function isEmpty(obj){
+    for(var p in obj) return false;
+    return true;
+}
+
+const SHUTDOWN_KIND = {
+    0: Const.isc_spb_prp_shutdown_db,
+    1: Const.isc_spb_prp_deny_new_transactions,
+    2: Const.isc_spb_prp_deny_new_attachments
+};
+const SHUTDOWNEX_KIND = {
+    0: Const.isc_spb_prp_force_shutdown,
+    1: Const.isc_spb_prp_transactions_shutdown,
+    2: Const.isc_spb_prp_attachments_shutdown
+};
+const SHUTDOWNEX_MODE = {
+    //0: isc_spb_prp_sm_normal,
+    1: Const.isc_spb_prp_sm_multi,
+    2: Const.isc_spb_prp_sm_single,
+    3: Const.isc_spb_prp_sm_full
+};
+const ShutdownMode = { NORMAL: 0, MULTI: 1, SINGLE: 2, FULL: 3 };
+const ShutdownKind = { FORCED: 0, DENY_TRANSACTION: 1, DENY_ATTACHMENT: 2 };
+
+/***************************************
+ *
+ *   Service Manager
+ *
+ ***************************************/
+
+class ServiceManager extends Events.EventEmitter {
+    constructor(connection) {
+        super();
+        this.connection = connection;
+        connection.svc = this;
+    }
+
+    _createOutputStream(optread, buffersize, callback) {
+        var self = this;
+        optread = optread || 'byline';
+        var t = new stream.Readable({ objectMode: optread === 'byline' }); // chunk by line
+        t.__proto__._read = function () {
+            var selfread = this;
+            var fct = optread === 'byline' ? self.readline : self.readeof;
+            fct.call(self, { buffersize: buffersize }, function (err, data) {
+                if (err) {
+                    selfread.push(err.message, Const.DEFAULT_ENCODING);
+                    return;
+                }
+                if (data.line && data.line.length)
+                    selfread.push(data.line, Const.DEFAULT_ENCODING);
+                else
+                    selfread.push(null);
+            });
+        }
+    
+        callback(null, t);
+    }
+
+    _infosmapping = {
+        "50"/*isc_info_svc_svr_db_info*/ : "dbinfo",
+        "51"/*isc_info_svc_get_license*/ : "licenses",
+        "52"/*isc_info_svc_get_license_mask*/ : "licenseoptions",
+        "53"/*isc_info_svc_get_config*/ : "fbconfig",
+        "54"/*isc_info_svc_version*/ : "svcversion",
+        "55"/*isc_info_svc_server_version*/ : "fbversion",
+        "56"/*isc_info_svc_implementation*/ : "fbimplementation",
+        "57"/*isc_info_svc_capabilities*/ : "fbcapatibilities",
+        "58"/*isc_info_svc_user_dbpath*/ : "pathsecuritydb",
+        "59"/*isc_info_svc_get_env*/ : "fbenv",
+        "60"/*isc_info_svc_get_env_lock*/ : "fbenvlock",
+        "61"/*isc_info_svc_get_env_msg*/ : "fbenvmsg",
+        "62"/*isc_info_svc_line*/ : "",
+        "63"/*isc_info_svc_to_eof*/ : "",
+        "64"/*isc_info_svc_timeout*/ : "",
+        "65"/*isc_info_svc_get_licensed_users*/ : "",
+        "66"/*isc_info_svc_limbo_trans*/ : "limbotrans",
+        "67"/*isc_info_svc_running*/ : "",
+        "68"/*isc_info_svc_get_users*/ : "fbusers",
+        "78"/*isc_info_svc_stdin*/ : ""
+    };
+
+    _processcapabilities(blr, res) {
+        var capArray = [
+            "WAL_SUPPORT",
+            "MULTI_CLIENT_SUPPORT",
+            "REMOTE_HOP_SUPPORT",
+            "NO_SVR_STATS_SUPPORT",
+            "NO_DB_STATS_SUPPORT",
+            "LOCAL_ENGINE_SUPPORT",
+            "NO_FORCED_WRITE_SUPPORT",
+            "NO_SHUTDOWN_SUPPORT",
+            "NO_SERVER_SHUTDOWN_SUPPORT",
+            "SERVER_CONFIG_SUPPORT",
+            "QUOTED_FILENAME_SUPPORT"
+        ];
+        var dbcapa = res[this._infosmapping[57]] = [];
+        var caps = blr.readInt32();
+    
+        for (var i = 0; i < capArray.length; ++i)
+            if (caps & (1 << i))
+                dbcapa.push(capArray[i]);
+    }
+
+    _processdbinfo(blr, res) {
+        var tinfo = blr.readByteCode();
+        var dbinfo = res[this._infosmapping[50]] = {};
+    
+        dbinfo.database = [];
+        for (; tinfo != Const.isc_info_flag_end; tinfo = blr.readByteCode()) {
+            switch (tinfo) {
+                case Const.isc_spb_dbname:
+                    dbinfo.database.push(blr.readString());
+                    break;
+                case Const.isc_spb_num_att:
+                    dbinfo.nbattachment = blr.readInt32();
+                    break;
+                case Const.isc_spb_num_db:
+                    dbinfo.nbdatabase = blr.readInt32();
+                    break;
+            }
+        }
+    }
+
+    _processquery(buffer, callback) {
+        if (!Buffer.isBuffer(buffer)) {
+            doError(new Error('Malformed service-manager response: missing BLR buffer'), callback);
+            return;
+        }
+
+        try {
+            var br = new BlrReader(buffer);
+            var tinfo = br.readByteCode();
+            var res = {};
+            res.result = 0;
+            for (; tinfo !== Const.isc_info_end; tinfo = br.readByteCode()) {
+                switch (tinfo) {
+                    case Const.isc_info_svc_server_version:
+                    case Const.isc_info_svc_implementation:
+                    case Const.isc_info_svc_user_dbpath:
+                    case Const.isc_info_svc_get_env:
+                    case Const.isc_info_svc_get_env_lock:
+                    case Const.isc_info_svc_get_env_msg:
+                        res[this._infosmapping[tinfo]] = br.readString();
+                        break;
+                    case Const.isc_info_svc_version:
+                        res[this._infosmapping[tinfo]] = br.readInt32();
+                        break;
+                    case Const.isc_info_svc_svr_db_info:
+                        this._processdbinfo(br, res);
+                        break;
+                    case Const.isc_info_svc_limbo_trans:
+                        // not implemented
+                        for (; tinfo !== isc_info_flag_end; tinfo = br.readByteCode())
+                            break;
+                    case Const.isc_info_svc_get_users:
+                        br.pos += 2
+                        res[this._infosmapping[tinfo]] = [];
+                        break;
+                    case Const.isc_spb_sec_username:
+                        var tuser = res[this._infosmapping[68]];
+                        tuser.push({});
+                        tuser[tuser.length - 1].username = br.readString();
+                        break;
+                    case Const.isc_spb_sec_firstname:
+                        var tuser = res[this._infosmapping[68]];
+                        var user = tuser[tuser.length-1];
+                        user.firstname = br.readString();
+                        break;
+                    case Const.isc_spb_sec_middlename:
+                        var tuser = res[this._infosmapping[68]];
+                        var user = tuser[tuser.length-1];
+                        user.middlename = br.readString();
+                        break;
+                    case Const.isc_spb_sec_lastname:
+                        var tuser = res[this._infosmapping[68]];
+                        var user = tuser[tuser.length-1];
+                        user.lastname = br.readString();
+                        break;
+                    case Const.isc_spb_sec_groupid:
+                        var tuser = res[this._infosmapping[68]];
+                        var user = tuser[tuser.length-1];
+                        user.groupid = br.readInt32();
+                        break;
+                    case Const.isc_spb_sec_userid:
+                        var tuser = res[this._infosmapping[68]];
+                        var user = tuser[tuser.length-1];
+                        user.userid = br.readInt32();
+        
+                        break;
+                    case Const.isc_spb_sec_admin:
+                        var tuser = res[this._infosmapping[68]];
+                        var user = tuser[tuser.length-1];
+                        user.admin = br.readInt32();
+                        break;
+        
+                    case Const.isc_info_svc_line:
+                        res.line = br.readString();
+                        break;
+        
+                    case Const.isc_info_svc_to_eof:
+                        res.line = br.readString();
+                        break;
+        
+                    case Const.isc_info_truncated:
+                        res.result = 1; // too much data for the result buffer increase size of it (buffersize parameter))
+                        break;
+        
+                    case Const.isc_info_data_not_ready:
+                        res.result = 2;
+                        break;
+        
+                    case Const.isc_info_svc_timeout:
+                        res.result = 3;
+                        break;
+        
+                    case Const.isc_info_svc_stdin:
+        
+                        break;
+        
+                    case Const.isc_info_svc_capabilities:
+                        this._processcapabilities(br, res);
+                        break;
+                }
+            }
+            callback(null, res);
+        } catch (err) {
+            doError(new Error('Malformed service-manager response: ' + err.message), callback);
+        }
+    }
+
+    detach(callback, force) {
+        var self = this;
+    
+        if (!force && self.connection._pending.length > 0) {
+            self.connection._detachAuto = true;
+            self.connection._detachCallback = callback;
+            return self;
+        }
+    
+        self.connection.svcdetach(function (err, obj) {
+    
+            self.connection.disconnect();
+            self.emit('detach', false);
+    
+            if (callback)
+                callback(err, obj);
+    
+        }, force);
+    
+        return self;
+    }
+
+    backup(options, callback) {
+        var dbpath = options.database || this.connection.options.filename || this.connection.options.database;
+        var verbose = options.verbose || false;
+        // format of bckfile {filename:'name', sizefile:''} sizefile is length of part in bytes
+        var bckfiles = options.backupfiles || options.files || null;
+        // for convenience
+        if (bckfiles) bckfiles = bckfiles.constructor !== Array?[{ filename: bckfiles, sizefile: '0' }]:bckfiles;
+        var factor = options.factor || 0; //If backing up to a physical tape device, this switch lets you specify the tape's blocking factor
+        var ignorechecksums = options.ignorechecksums || false;
+        var ignorelimbo = options.ignorelimbo || false;
+        var metadataonly = options.metadataonly || false;
+        var nogarbagecollect = options.nogarbasecollect || false;
+        var olddescriptions = options.olddescriptions || false;
+        var nontransportable = options.nontransportable || false;
+        var convert = options.convert || false;
+        var expand = options.expand || false;
+        var notriggers = options.notriggers || false;
+    
+        if (dbpath == null || dbpath.length === 0) {
+            doError(new Error('No database specified'), callback);
+            return;
+        }
+    
+        if (bckfiles == null || bckfiles.length === 0) {
+            doError(new Error('No backup path specified'), callback);
+            return;
+        }
+    
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_backup);
+        blr.addString2(Const.isc_spb_dbname, dbpath, Const.DEFAULT_ENCODING);
+        for (var i = 0; i < bckfiles.length; i++) {
+            blr.addString2(Const.isc_spb_bkp_file, bckfiles[i].filename, Const.DEFAULT_ENCODING);
+            if (i !== bckfiles.length - 1) // not the end, so we need to write the size of this part (gsplit)
+                blr.addString2(Const.isc_spb_bkp_length, bckfiles[i].sizefile, Const.DEFAULT_ENCODING);
+        }
+        if (factor)
+            blr.addByteInt32(Const.isc_spb_bkp_factor, factor);
+    
+        var opts = 0;
+        if (ignorechecksums) opts = opts | Const.isc_spb_bkp_ignore_checksums;
+        if (ignorelimbo) opts = opts | Const.isc_spb_bkp_ignore_limbo;
+        if (metadataonly) opts = opts | Const.isc_spb_bkp_metadata_only;
+        if (nogarbagecollect) opts = opts | Const.isc_spb_bkp_no_garbage_collect;
+        if (olddescriptions) opts = opts | Const.isc_spb_bkp_old_descriptions;
+        if (nontransportable) opts = opts | Const.isc_spb_bkp_non_transportable;
+        if (convert) opts = opts | Const.isc_spb_bkp_convert;
+        if (expand) opts = opts | Const.isc_spb_bkp_expand;
+        if (notriggers) opts = opts | Const.isc_spb_bkp_no_triggers;
+        if (opts)
+            blr.addByteInt32(Const.isc_spb_options, opts);
+        if (verbose)
+            blr.addByte(Const.isc_spb_verbose);
+        var self = this;
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    }
+
+    nbackup(options, callback) {
+        var dbpath = options.database || this.connection.options.filename || this.connection.options.database;
+        var bckfile = options.backupfile || options.file || null;
+        var level = options.level || 0; // nb day for incremental
+        var notriggers = options.notriggers || false;
+        var direct = options.direct || 'on'; // on or off direct write I/O
+    
+        if (dbpath == null || dbpath.length === 0) {
+            doError(new Error('No database specified'), callback);
+            return;
+        }
+    
+        if (bckfile == null || bckfile.length === 0) {
+            doError(new Error('No backup path specified'), callback);
+            return;
+        }
+    
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_nbak);
+        blr.addString2(Const.isc_spb_dbname, dbpath, Const.DEFAULT_ENCODING);
+        blr.addString2(Const.isc_spb_nbk_file, bckfile, Const.DEFAULT_ENCODING);
+        blr.addByteInt32(Const.isc_spb_nbk_level, level);
+        blr.addString2(Const.isc_spb_nbk_direct, direct, Const.DEFAULT_ENCODING);
+        var opts = 0;
+        if (notriggers) opts = opts | Const.isc_spb_nbk_no_triggers;
+        blr.addByteInt32(Const.isc_spb_options, opts);
+        var self = this;
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    }
+
+    restore(options, callback) {
+        var bckfiles = options.backupfiles || options.files || null; // format bckfiles ['file1', 'file2', 'file3']
+        // for convenience
+        if (bckfiles) bckfiles = bckfiles.constructor !== Array?[bckfiles]:bckfiles;
+        var dbfile = options.database || this.connection.options.filename || this.connection.options.database;;
+        var verbose = options.verbose || false;
+        var cachebuffers = options.cachebuffers || 2048; // gbak -buffers
+        var pagesize = options.pagesize || 4096; // gbak -page_size
+        var readonly = options.readonly || false; // gbak -mode
+        var deactivateindexes = options.deactivateindexes || false;
+        var	noshadow = options.noshadow || false;
+        var	novalidity = options.novalidity || false;
+        var	individualcommit = options.individualcommit || true; // otherwise no data
+        var	replace = options.replace || false;
+        var	create = options.create || true;
+        var useallspace = options.useallspace || false;
+        var metadataonly = options.metadataonly || false;
+        var fixfssdata = options.fixfssdata || null;
+        var fixfssmetadata = options.fixfssmetadata || null;
+    
+        if (bckfiles == null || bckfiles.length === 0) {
+            doError(new Error('No backup file specified'), callback);
+            return;
+        }
+    
+        if (dbfile == null || dbfile.length === 0) {
+            doError(new Error('No database path specified'), callback);
+            return;
+        }
+    
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_restore);
+        for (var i = 0; i < bckfiles.length; i++) {
+            blr.addString2(Const.isc_spb_bkp_file, bckfiles[i], Const.DEFAULT_ENCODING);
+        }
+        blr.addString2(Const.isc_spb_dbname, dbfile, Const.DEFAULT_ENCODING);
+        blr.addByte(Const.isc_spb_res_buffers);
+        blr.addInt32(cachebuffers);
+        blr.addByte(Const.isc_spb_res_page_size);
+        blr.addInt32(pagesize);
+        blr.addByte(Const.isc_spb_res_access_mode);
+        if (readonly)
+            blr.addByte(Const.isc_spb_prp_am_readonly);
+        else
+            blr.addByte(Const.isc_spb_prp_am_readwrite);
+        if (fixfssdata) blr.addString2(Const.isc_spb_res_fix_fss_data, fixfssdata, Const.DEFAULT_ENCODING);
+        if (fixfssmetadata) blr.addString2(Const.isc_spb_res_fix_fss_metadata, fixfssmetadata, Const.DEFAULT_ENCODING);
+        var opts = 0;
+        if (deactivateindexes) opts = opts | Const.isc_spb_res_deactivate_idx;
+        if (noshadow) opts = opts | Const.isc_spb_res_no_shadow;
+        if (novalidity) opts = opts | Const.isc_spb_res_no_validity;
+        if (individualcommit) opts = opts | Const.isc_spb_res_one_at_a_time;
+        if (replace) opts = opts | Const.isc_spb_res_replace;
+        if (create) opts = opts | Const.isc_spb_res_create;
+        if (useallspace) opts = opts | Const.isc_spb_res_use_all_space;
+        if (metadataonly) opts = opts | Const.isc_spb_res_fix_fss_metadata;
+        if (opts)
+            blr.addByteInt32(Const.isc_spb_options, opts);
+        if (verbose)
+            blr.addByte(Const.isc_spb_verbose);
+        var self = this;
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    }
+
+    nrestore(options, callback) {
+        var bckfiles = options.backupfiles || options.files || null; // format bckfiles ['file1', 'file2', 'file3']
+        // for convenience
+        if (bckfiles) bckfiles = bckfiles.constructor !== Array?[bckfiles]:bckfiles;
+        var dbpath = options.database || this.connection.options.filename || this.connection.options.database;
+    
+        if (bckfiles == null || bckfiles.length === 0) {
+            doError(new Error('No backup file specified'), callback);
+            return;
+        }
+    
+        if (dbpath == null || bckfiles.length === 0) {
+            doError(new Error('No database path specified'), callback);
+            return;
+        }
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_nrest);
+        for (var i = 0; i < bckfiles.length; i++) {
+            blr.addString2(Const.isc_spb_nbk_file, bckfiles[i], Const.DEFAULT_ENCODING);
+        }
+        blr.addString2(Const.isc_spb_dbname, dbpath, Const.DEFAULT_ENCODING);
+        var self = this;
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    }
+
+    _fixpropertie(options, callback) {
+        var dbpath = options.database || this.connection.options.filename || this.connection.options.database;
+        var dialect = options.dialect || null;
+        var sweep = options.sweepinterval || null;
+        var pagebuffers = options.nbpagebuffers || null;
+        var online = options.bringonline || false;
+        var shutdown = options.shutdown != null ? options.shutdown : null; // 0 Forced, 1 deny transaction, 2 deny attachment
+        var shutdowndelay = options.shutdowndelay || 0;
+        var shutdownmode = options.shutdownmode; // 0 normal 1 multi 2 single 3 full
+        var shadow = options.activateshadow || false;
+        var forcewrite = options.forcewrite;
+        var reservespace = options.reservespace;
+        var accessmode = options.accessmode; // 0 readonly 1 readwrite
+    
+        if (dbpath == null || dbpath.length === 0) {
+            doError(new Error('No database specified'), callback);
+            return;
+        }
+    
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_properties);
+        blr.addString2(Const.isc_spb_dbname, dbpath, Const.DEFAULT_ENCODING);
+        if (dialect) blr.addByteInt32(Const.isc_spb_prp_set_sql_dialect, dialect);
+        if (sweep) blr.addByteInt32(Const.isc_spb_prp_sweep_interval, sweep);
+        if (pagebuffers) blr.addByteInt32(Const.isc_spb_prp_page_buffers, pagebuffers);
+        if (shutdown != null) {
+            if (shutdownmode != null) {
+                if (SHUTDOWNEX_KIND[shutdown] === undefined) {
+                    doError(new Error('Invalid shutdown kind'), callback);
+                    return;
+                }
+                if (SHUTDOWNEX_MODE[shutdownmode] === undefined) {
+                    doError(new Error('Invalid shutdown mode'), callback);
+                    return;
+                }
+    
+                // New shutdown with mode
+                blr.addBytes([Const.isc_spb_prp_shutdown_mode, SHUTDOWNEX_MODE[shutdownmode]]);
+                blr.addByteInt32(SHUTDOWNEX_KIND[shutdown], shutdowndelay);
+            } else {
+                // Old shutdown
+                blr.addByteInt32(SHUTDOWN_KIND[shutdown], shutdowndelay);
+            }
+        }
+        if (forcewrite) blr.addBytes([Const.isc_spb_prp_write_mode, Const.isc_spb_prp_wm_sync]);
+        if (forcewrite === false) blr.addBytes([Const.isc_spb_prp_write_mode, Const.isc_spb_prp_wm_async]);
+        if (accessmode === 1) blr.addBytes([Const.isc_spb_prp_access_mode, Const.isc_spb_prp_am_readwrite]);
+        if (accessmode === 0) blr.addBytes([Const.isc_spb_prp_access_mode, Const.isc_spb_prp_am_readonly]);
+        if (reservespace) blr.addBytes([Const.isc_spb_prp_reserve_space, Const.isc_spb_prp_res]);
+        if (reservespace != null && !reservespace) blr.addBytes([Const.isc_spb_prp_reserve_space, Const.isc_spb_prp_res_use_full]);
+        var opts = 0;
+        if (shadow) opts = opts | Const.isc_spb_prp_activate;
+        if (online) opts = opts | Const.isc_spb_prp_db_online;
+        if (opts)
+            blr.addByteInt32(Const.isc_spb_options, opts);
+        var self = this;
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    }
+
+    setDialect(db, dialect, callback) {
+        this._fixpropertie({ database: db, dialect: dialect }, callback);
+    }
+
+    setSweepinterval(db, sweepinterval, callback) {
+        this._fixpropertie({ database: db, sweepinterval: sweepinterval }, callback);
+    }
+
+    setCachebuffer(db, nbpages, callback) {
+        this._fixpropertie({ database: db, nbpagebuffers: nbpages }, callback);
+    }
+
+    BringOnline(db, callback) {
+        this._fixpropertie({ database: db, bringonline: true }, callback);
+    }
+
+    Shutdown(db, kind, delay, mode, callback) {
+        // mode parameter is for server version >= 2.0
+        if (mode instanceof Function) {
+            callback = mode;
+            mode = undefined;
+        }
+    
+        this._fixpropertie({ database: db, shutdown: kind, shutdowndelay: delay, shutdownmode: mode }, callback);
+    }
+
+    setShadow(db, val, callback) {
+        this._fixpropertie({ database: db, activateshadow : val }, callback);
+    }
+
+    setForcewrite(db, val, callback) {
+        this._fixpropertie({ database: db, forcewrite : val }, callback);
+    }
+
+    setReservespace(db, val, callback) {
+        this._fixpropertie({ database: db, reservespace : val }, callback);
+    }
+
+    setReadonlyMode(db, callback) {
+        this._fixpropertie({ database: db, accessmode : 0 }, callback);
+    }
+
+    setReadwriteMode(db, callback) {
+        this._fixpropertie({ database: db, accessmode : 1 }, callback);
+    }
+
+    validate(options, callback) {
+        var dbpath = options.database || this.connection.options.filename || this.connection.options.database;
+        var checkdb = options.checkdb || false;
+        var ignorechecksums = options.ignorechecksums || false;
+        var killshadows = options.killshadows || false;
+        var mend = options.mend || false;
+        var validate = options.validate || false;
+        var full = options.full || false;
+        var sweep = options.sweep || false;
+        var listlimbo = options.listlimbo || false;
+        var icu = options.icu || false;
+    
+        if (dbpath == null || dbpath.length === 0) {
+            doError(new Error('No database specified'), callback);
+            return;
+        }
+    
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_repair);
+        blr.addString2(Const.isc_spb_dbname, dbpath, Const.DEFAULT_ENCODING);
+        var opts = 0;
+        if (checkdb) opts = opts | Const.isc_spb_rpr_check_db;
+        if (ignorechecksums) opts = opts | Const.isc_spb_rpr_ignore_checksum;
+        if (killshadows) opts = opts | Const.isc_spb_rpr_kill_shadows;
+        if (mend) opts = opts | Const.isc_spb_rpr_mend_db;
+        if (validate) opts = opts | Const.isc_spb_rpr_validate_db;
+        if (full) opts = opts | Const.isc_spb_rpr_full;
+        if (sweep) opts = opts | Const.isc_spb_rpr_sweep_db;
+        if (listlimbo) opts = opts | Const.isc_spb_rpr_list_limbo_trans;
+        if (icu) opts = opts | Const.isc_spb_rpr_icu;
+        blr.addByteInt32(Const.isc_spb_options, opts);
+        var self = this;
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    }
+
+    commit(db, transactid, callback) {
+        var dbpath = db || this.connection.options.filename || this.connection.options.database;
+        if (dbpath == null || dbpath.length === 0) {
+            doError(new Error('No database specified'), callback);
+            return;
+        }
+    
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_repair);
+        blr.addString2(Const.isc_spb_dbname, dbpath, Const.DEFAULT_ENCODING);
+        blr.addByteInt32(Const.isc_spb_rpr_commit_trans, transactid);
+        var self = this;
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(null, null, callback);
+        });
+    }
+
+    rollback(db, transactid, callback) {
+        var dbpath = db || this.connection.options.filename || this.connection.options.database;
+        if (dbpath == null || dbpath.length === 0) {
+            doError(new Error('No database specified'), callback);
+            return;
+        }
+    
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_repair);
+        blr.addString2(Const.isc_spb_dbname, dbpath, Const.DEFAULT_ENCODING);
+        blr.addByteInt32(Const.isc_spb_rpr_rollback_trans, transactid);
+        var self = this;
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(null, null, callback);
+        });
+    }
+
+    recover(db, transactid, callback) {
+        var dbpath = db || this.connection.options.filename || this.connection.options.database;
+        if (dbpath == null || dbpath.length === 0) {
+            doError(new Error('No database specified'), callback);
+            return;
+        }
+    
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_repair);
+        blr.addString2(Const.isc_spb_dbname, dbpath, Const.DEFAULT_ENCODING);
+        blr.addByteInt32(Const.isc_spb_rpr_recover_two_phase, transactid);
+        var self = this;
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(null, null, callback);
+        });
+    }
+
+    getStats(options, callback) {
+        var dbpath = options.database || this.connection.options.filename || this.connection.options.database;
+        var record = options.record || false;
+        var nocreation = options.nocreation || false;
+        var tables = options.tables || false;
+        var pages = options.pages || false;
+        var header = options.header || false;
+        var indexes = options.indexes || false;
+        var tablesystem = options.tablesystem || false;
+        var encryption = options.encryption || false;
+        var objects = options.objects || null; // space-separated list of object index,table,systemtable
+        if (dbpath == null || dbpath.length === 0) {
+            doError(new Error('No database specified'), callback);
+            return;
+        }
+    
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_db_stats);
+        blr.addString2(Const.isc_spb_dbname, dbpath, Const.DEFAULT_ENCODING);
+        var opts = 0;
+        if (record) opts = opts | Const.isc_spb_sts_record_versions;
+        if (nocreation) opts = opts | Const.isc_spb_sts_nocreation;
+        if (tables) opts = opts | Const.isc_spb_sts_table;
+        if (pages) opts = opts | Const.isc_spb_sts_data_pages;
+        if (header) opts = opts | Const.isc_spb_sts_hdr_pages;
+        if (indexes) opts = opts | Const.isc_spb_sts_idx_pages;
+        if (tablesystem) opts = opts | Const.isc_spb_sts_sys_relations;
+        if (encryption) opts = opts | Const.isc_spb_sts_encryption;
+        if (opts)
+            blr.addByteInt32(Const.isc_spb_options, opts);
+        if (objects) blr.addString2(Const.isc_spb_command_line, objects, Const.DEFAULT_ENCODING);
+        var self = this;
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    
+    }
+
+    getLog(options, callback) {
+        var self = this;
+        var blr = this.connection._blr;
+        var optread = options.optread || 'byline';
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_get_fb_log);
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(optread, options.buffersize, callback);
+        });
+    }
+
+    getUsers(username, callback) {
+        var self = this;
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_display_user);
+        if (username) blr.addString2(Const.isc_spb_sec_username, username, Const.DEFAULT_ENCODING);
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self.readusers({}, callback);
+        });
+    }
+
+    addUser(username, password, options, callback) {
+        var rolename = options.rolename || null;
+        var groupname = options.groupname || null;
+        var firsname = options.firstname || null;
+        var middlename = options.middlename || null;
+        var lastname = options.lastname || null;
+        var userid = options.userid || null;
+        var groupid = options.groupid || null;
+        var admin = options.admin || null;
+    
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_add_user);
+        blr.addString2(Const.isc_spb_sec_username, username, Const.DEFAULT_ENCODING);
+        blr.addString2(Const.isc_spb_sec_password, password, Const.DEFAULT_ENCODING);
+        if (rolename) blr.addString2(Const.isc_dpb_sql_role_name, rolename, Const.DEFAULT_ENCODING);
+        if (groupname) blr.addString2(Const.isc_spb_sec_groupname, groupname, Const.DEFAULT_ENCODING);
+        if (firsname) blr.addString2(Const.isc_spb_sec_firstname, firsname, Const.DEFAULT_ENCODING);
+        if (middlename) blr.addString2(Const.isc_spb_sec_middlename, middlename, Const.DEFAULT_ENCODING);
+        if (lastname) blr.addString2(Const.isc_spb_sec_lastname, lastname, Const.DEFAULT_ENCODING);
+        if (userid != null) blr.addByteInt32(Const.isc_spb_sec_userid, userid);
+        if (groupid != null) blr.addByteInt32(Const.isc_spb_sec_groupid, groupid);
+        if (admin != null) blr.addByteInt32(Const.isc_spb_sec_admin, admin);
+    
+        var self = this;
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    }
+
+    editUser(username, options, callback) {
+        var rolename = options.rolename || null;
+        var groupname = options.groupname || null;
+        var firsname = options.firstname || null;
+        var middlename = options.middlename || null;
+        var lastname = options.lastname || null;
+        var userid = options.userid || null;
+        var groupid = options.groupid || null;
+        var admin = options.admin || null;
+        var password = options.password || null;
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_modify_user);
+        blr.addString2(Const.isc_spb_sec_username, username, Const.DEFAULT_ENCODING);
+        if (password) blr.addString2(Const.isc_spb_sec_password, password, Const.DEFAULT_ENCODING);
+        if (rolename) blr.addString2(Const.isc_dpb_sql_role_name, rolename, Const.DEFAULT_ENCODING);
+        if (groupname) blr.addString2(Const.isc_spb_sec_groupname, groupname, Const.DEFAULT_ENCODING);
+        if (firsname) blr.addString2(Const.isc_spb_sec_firstname, firsname, Const.DEFAULT_ENCODING);
+        if (middlename) blr.addString2(Const.isc_spb_sec_middlename, middlename, Const.DEFAULT_ENCODING);
+        if (lastname) blr.addString2(Const.isc_spb_sec_lastname, lastname, Const.DEFAULT_ENCODING);
+        if (userid != null) blr.addByteInt32(Const.isc_spb_sec_userid, userid);
+        if (groupid != null) blr.addByteInt32(Const.isc_spb_sec_groupid, groupid);
+        if (admin != null) blr.addByteInt32(Const.isc_spb_sec_admin, admin);
+    
+        var self = this;
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    }
+
+    removeUser(username, rolename, callback) {
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_delete_user);
+        blr.addString2(Const.isc_spb_sec_username, username, Const.DEFAULT_ENCODING);
+        if (rolename) blr.addString2(Const.isc_dpb_sql_role_name, rolename, Const.DEFAULT_ENCODING);
+    
+        var self = this, options = {};
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    }
+
+    getFbserverInfos(infos, options, callback) {
+        var buffersize = options.buffersize || 2048;
+        var timeout = options.timeout || 1;
+        var opts = {
+            "dbinfo" : Const.isc_info_svc_svr_db_info,
+            "fbconfig" : Const.isc_info_svc_get_config,
+            "svcversion" : Const.isc_info_svc_version,
+            "fbversion" : Const.isc_info_svc_server_version,
+            "fbimplementation" : Const.isc_info_svc_implementation,
+            "fbcapatibilities" : Const.isc_info_svc_capabilities,
+            "pathsecuritydb" : Const.isc_info_svc_user_dbpath,
+            "fbenv" : Const.isc_info_svc_get_env,
+            "fbenvlock" : Const.isc_info_svc_get_env_lock,
+            "fbenvmsg" : Const.isc_info_svc_get_env_msg
+        };
+        // if infos is empty all options are asked to the service
+    
+        var tops = [], empty = isEmpty(infos);
+        for (let popts in opts)
+            if (empty || infos[popts])
+                tops.push(opts[popts]);
+    
+        var self = this;
+        this.connection.svcquery(tops, buffersize, timeout, function (err, data) {
+            if (err || !data.buffer) {
+                doError(new Error(err||'Bad query return'), callback);
+                return;
+            }
+            self._processquery(data.buffer, callback);
+        });
+    }
+
+    startTrace(options, callback) {
+        var self = this;
+        var blr = this.connection._blr;
+        var configfile = options.configfile || '';
+        var tracename = options.tracename || '';
+    
+        if (configfile.length === 0) {
+            doError(new Error('No config filename specified'), callback);
+            return;
+        }
+        if (tracename.length === 0) {
+            doError(new Error('No tracename specified'), callback);
+            return;
+        }
+    
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_trace_start);
+        blr.addString2(Const.isc_spb_trc_cfg, configfile, Const.DEFAULT_ENCODING);
+        blr.addString2(Const.isc_spb_trc_name, tracename, Const.DEFAULT_ENCODING);
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    }
+
+    suspendTrace(options, callback) {
+        var self = this;
+        var blr = this.connection._blr;
+        var traceid = options.traceid || null;
+    
+        if (traceid == null) {
+            doError(new Error('No traceid specified'), callback);
+            return;
+        }
+    
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_trace_suspend);
+        blr.addByteInt32(Const.isc_spb_trc_id, traceid);
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    }
+
+    resumeTrace(options, callback) {
+        var self = this;
+        var blr = this.connection._blr;
+        var traceid = options.traceid || null;
+    
+        if (traceid == null) {
+            doError(new Error('No traceid specified'), callback);
+            return;
+        }
+    
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_trace_resume);
+        blr.addByteInt32(Const.isc_spb_trc_id, traceid);
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    }
+
+    stopTrace(options, callback) {
+        var self = this;
+        var blr = this.connection._blr;
+        var traceid = options.traceid || null;
+    
+        if (traceid == null) {
+            doError(new Error('No traceid specified'), callback);
+            return;
+        }
+    
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_trace_stop);
+        blr.addByteInt32(Const.isc_spb_trc_id, traceid);
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    }
+
+    getTraceList(options, callback) {
+        var self = this;
+        var blr = this.connection._blr;
+        blr.pos = 0;
+        blr.addByte(Const.isc_action_svc_trace_list);
+        this.connection.svcstart(blr, function (err, data) {
+            if (err) {
+                doError(new Error(err), callback);
+                return;
+            }
+            self._createOutputStream(options.optread, options.buffersize, callback);
+        });
+    }
+
+    readline(options, callback) {
+        var buffersize = options.buffersize || 2048;
+        var timeout = options.timeout || 60;
+        var self = this;
+        this.connection.svcquery([Const.isc_info_svc_line], buffersize, timeout, function (err, data) {
+            if (err || !data.buffer) {
+                doError(new Error(err||'Bad query return'), callback);
+                return;
+            }
+            self._processquery(data.buffer, callback);
+        });
+    }
+
+    readeof(options, callback) {
+        var buffersize = options.buffersize || (8 * 1024);
+        var timeout = options.timeout || 60;
+        var self = this;
+        this.connection.svcquery([Const.isc_info_svc_to_eof], buffersize, timeout, function (err, data) {
+            if (err || !data.buffer) {
+                doError(new Error(err||'Bad query return'), callback);
+                return;
+            }
+            self._processquery(data.buffer, callback);
+        });
+    }
+
+    hasRunningAction(options, callback) {
+        var buffersize = options.buffersize || 2048;
+        var timeout = options.timeout || 60;
+        var self = this;
+        this.connection.svcquery([Const.isc_info_svc_running], buffersize, timeout, function (err, data) {
+            if (err || !data.buffer) {
+                doError(new Error(err||'Bad query return'), callback);
+                return;
+            }
+            self._processquery(data.buffer, callback);
+        });
+    }
+
+    readusers(options, callback) {
+        var buffersize = options.buffersize || 2048;
+        var timeout = options.timeout || 60;
+        var self = this;
+        this.connection.svcquery([Const.isc_info_svc_get_users], buffersize, timeout, function (err, data) {
+            if (err || !data.buffer) {
+                doError(new Error(err||'Bad query return'), callback);
+                return;
+            }
+            self._processquery(data.buffer, callback);
+        });
+    }
+
+    readlimbo(options, callback) {
+        var buffersize = options.buffersize || 2048;
+        var timeout = options.timeout || 60;
+        var self = this;
+        this.connection.svcquery([Const.isc_info_svc_limbo_trans], buffersize, timeout, function (err, data) {
+            if (err || !data.buffer) {
+                doError(new Error(err||'Bad query return'), callback);
+                return;
+            }
+            self._processquery(data.buffer, callback);
+        });
+    }
+
+}
+
+ServiceManager.ShutdownMode = ShutdownMode;
+ServiceManager.ShutdownKind = ShutdownKind;
+
+module.exports = ServiceManager;