ueberdb2 4.1.1 → 4.1.2

package/databases/cassandra_db.ts

@@ -1,265 +0,0 @@
-/**
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS-IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import AbstractDatabase, {Settings} from '../lib/AbstractDatabase';
-import cassandra, {ArrayOrObject, Client, types, ValueCallback} from 'cassandra-driver';
-import ResultSet = types.ResultSet;
-
-
-type Result = {
-  rows: any[];
-};
-
-export type BulkObject = {
-  type: string
-  key:string
-  value?: string
-};
-
-export const Database = class Cassandra_db extends AbstractDatabase {
-  private client: Client | undefined;
-  private pool: any;
-  /**
-   * @param {Object} settings The required settings object to initiate the Cassandra database
-   * @param {String[]} settings.clientOptions See
-   *     http://www.datastax.com/drivers/nodejs/2.0/global.html#ClientOptions for a full set of
-   *     options that can be used
-   * @param {String} settings.columnFamily The column family that should be used to store data. The
-   *     column family will be created if it doesn't exist
-   * @param {Function} [settings.logger] Function that will be used to pass on log events emitted by
-   *     the Cassandra driver. See https://github.com/datastax/nodejs-driver#logging for more
-   *     information
-   */
-  constructor(settings:Settings) {
-    super();
-    if (!settings.clientOptions) {
-      throw new Error('The Cassandra client options should be defined');
-    }
-    if (!settings.columnFamily) {
-      throw new Error('The Cassandra column family should be defined');
-    }
-    this.settings = {database: settings.database};
-    this.settings.clientOptions = settings.clientOptions;
-    this.settings.columnFamily = settings.columnFamily;
-    this.settings.logger = settings.logger;
-  }
-
-  /**
-   * Initializes the Cassandra client, connects to Cassandra and creates the CF if it didn't exist
-   * already
-   *
-   * @param  {Function}   callback        Standard callback method.
-   * @param  {Error}      callback.err    An error object (if any.)
-   */
-  init(callback: (arg: any)=>{}) {
-    // Create a client
-    this.client = new cassandra.Client(this.settings.clientOptions);
-
-    // Pass on log messages if a logger has been configured
-    if (this.settings.logger) {
-      this.client.on('log', this.settings.logger);
-    }
-
-    // Check whether our column family already exists and create it if necessary
-    this.client.execute(
-        'SELECT columnfamily_name FROM system.schema_columnfamilies WHERE keyspace_name = ?',
-        [this.settings.clientOptions.keyspace],
-        (err, result) => {
-          if (err) {
-            return callback(err);
-          }
-
-          let isDefined = false;
-          const length = result.rows.length;
-          for (let i = 0; i < length; i++) {
-            if (result.rows[i].columnfamily_name === this.settings.columnFamily) {
-              isDefined = true;
-              break;
-            }
-          }
-
-          if (isDefined) {
-            return callback(null);
-          } else {
-            const cql =
-                `CREATE COLUMNFAMILY "${this.settings.columnFamily}" ` +
-                '(key text PRIMARY KEY, data text)';
-            this.client && this.client.execute(cql, callback);
-          }
-        });
-  }
-
-  /**
-   * Gets a value from Cassandra
-   *
-   * @param  {String}     key               The key for which the value should be retrieved
-   * @param  {Function}   callback          Standard callback method
-   * @param  {Error}      callback.err      An error object, if any
-   * @param  {String}     callback.value    The value for the given key (if any)
-   */
-  get(key:string, callback: (err:Error | null, data?:any)=>{}) {
-    const cql = `SELECT data FROM "${this.settings.columnFamily}" WHERE key = ?`;
-    this.client && this.client.execute(cql, [key], (err, result) => {
-      if (err) {
-        return callback(err);
-      }
-
-      if (!result.rows || result.rows.length === 0) {
-        return callback(null, null);
-      }
-
-      return callback(null, result.rows[0].data);
-    });
-  }
-
-  /**
-   * Cassandra has no native `findKeys` method. This function implements a naive filter by
-   * retrieving *all* the keys and filtering those. This should obviously be used with the utmost
-   * care and is probably not something you want to run in production.
-   *
-   * @param  {String}     key               The filter for keys that should match
-   * @param  {String}     [notKey]          The filter for keys that shouldn't match
-   * @param  {Function}   callback          Standard callback method
-   * @param  {Error}      callback.err      An error object, if any
-   * @param  {String[]}   callback.keys     An array of keys that match the specified filters
-   */
-  findKeys(key:string, notKey:string, callback: Function) {
-    let cql = null;
-    if (!notKey) {
-      // Get all the keys
-      cql = `SELECT key FROM "${this.settings.columnFamily}"`;
-      this.client && this.client.execute(cql, (err: Error, result:Result) => {
-        if (err) {
-          return callback(err);
-        }
-
-        // Construct a regular expression based on the given key
-        const regex = new RegExp(`^${key.replace(/\*/g, '.*')}$`);
-
-        const keys:string[] = [];
-        result.rows.forEach((row) => {
-          if (regex.test(row.key)) {
-            keys.push(row.key);
-          }
-        });
-
-        return callback(null, keys);
-      });
-    } else if (notKey === '*:*:*') {
-      // restrict key to format 'text:*'
-      const matches = /^([^:]+):\*$/.exec(key);
-      if (matches) {
-        // Get the 'text' bit out of the key and get all those keys from a special column.
-        // We can retrieve them from this column as we're duplicating them on .set/.remove
-        cql = `SELECT * from "${this.settings.columnFamily}" WHERE key = ?`;
-        this.client &&
-        this.client
-            .execute(cql, [`ueberdb:keys:${matches[1]}`], (err, result) => {
-              if (err) {
-                return callback(err);
-              }
-
-              if (!result.rows || result.rows.length === 0) {
-                return callback(null, []);
-              }
-
-              const keys = result.rows.map((row) => row.data);
-              return callback(null, keys);
-            });
-      } else {
-        const msg =
-            'Cassandra db only supports key patterns like pad:* when notKey is set to *:*:*';
-        return callback(new Error(msg), null);
-      }
-    } else {
-      return callback(new Error('Cassandra db currently only supports *:*:* as notKey'), null);
-    }
-  }
-
-  /**
-   * Sets a value for a key
-   *
-   * @param  {String}     key             The key to set
-   * @param  {String}     value           The value associated to this key
-   * @param  {Function}   callback        Standard callback method
-   * @param  {Error}      callback.err    An error object, if any
-   */
-  set(key: string, value:string, callback:()=>{}) {
-    this.doBulk([{type: 'set', key, value}], callback);
-  }
-
-  /**
-   * Removes a key and it's value from the column family
-   *
-   * @param  {String}     key             The key to remove
-   * @param  {Function}   callback        Standard callback method
-   * @param  {Error}      callback.err    An error object, if any
-   */
-  remove(key:string, callback: ValueCallback<ResultSet>) {
-    this.doBulk([{type: 'remove', key}], callback);
-  }
-
-
-  /**
-   * Performs multiple operations in one action
-   *
-   * @param  {Object[]}   bulk            The set of operations that should be performed
-   * @param  {Function}   callback        Standard callback method
-   * @param  {Error}      callback.err    An error object, if any
-   */
-  doBulk(bulk:BulkObject[], callback:ValueCallback<ResultSet>) {
-    const queries:Array<string | {query: string, params?: ArrayOrObject}> = [];
-    bulk.forEach((operation) => {
-      // We support finding keys of the form `test:*`. If anything matches, we will try and save
-      // this
-      const matches = /^([^:]+):([^:]+)$/.exec(operation.key);
-      if (operation.type === 'set') {
-        queries.push({
-          query: `UPDATE "${this.settings.columnFamily}" SET data = ? WHERE key = ?`,
-          params: [operation.value, operation.key],
-        });
-
-        if (matches) {
-          queries.push({
-            query: `UPDATE "${this.settings.columnFamily}" SET data = ? WHERE key = ?`,
-            params: ['1', `ueberdb:keys:${matches[1]}`],
-          });
-        }
-      } else if (operation.type === 'remove') {
-        queries.push({
-          query: `DELETE FROM "${this.settings.columnFamily}" WHERE key=?`,
-          params: [operation.key],
-        });
-
-        if (matches) {
-          queries.push({
-            query: `DELETE FROM "${this.settings.columnFamily}" WHERE key = ?`,
-            params: [`ueberdb:keys:${matches[1]}`],
-          });
-        }
-      }
-    });
-    this.client && this.client.batch(queries, {prepare: true}, callback);
-  }
-
-  /**
-   * Closes the Cassandra connection
-   *
-   * @param  {Function}   callback        Standard callback method
-   * @param  {Error}      callback.err    Error object in case something goes wrong
-   */
-  close(callback: ()=>{}) {
-    this.pool.shutdown(callback);
-  }
-};

package/databases/couch_db.ts

@@ -1,189 +0,0 @@
-/**
- * 2012 Max 'Azul' Wiehle
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS-IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import AbstractDatabase, {Settings} from '../lib/AbstractDatabase';
-import http, {Agent} from 'http';
-import nano from 'nano';
-import {BulkObject} from './cassandra_db';
-
-type CouchDBSettings = {
-    url: string,
-    requestDefaults: {
-      auth?: {
-        username: string,
-        password: string,
-      },
-      agent: Agent
-    }
-};
-export const Database = class Couch_db extends AbstractDatabase {
-  private agent: Agent | null;
-  private db: nano.DocumentScope<string> | null;
-  constructor(settings: Settings) {
-    super();
-    this.agent = null;
-    this.db = null;
-    this.settings = settings;
-
-    // force some settings
-    // used by CacheAndBufferLayer.js
-    this.settings.cache = 1000;
-    this.settings.writeInterval = 100;
-    this.settings.json = false;
-  }
-
-  get isAsync() { return true; }
-
-  async init() {
-    this.agent = new http.Agent({
-      keepAlive: true,
-      maxSockets: this.settings.maxListeners || 1,
-    });
-
-    const coudhDBSettings: CouchDBSettings = {
-      url: `http://${this.settings.host}:${this.settings.port}`,
-      requestDefaults: {
-        agent: this.agent,
-      },
-    };
-
-    if (this.settings.user && this.settings.password) {
-      coudhDBSettings.requestDefaults.auth = {
-        username: this.settings.user,
-        password: this.settings.password,
-      };
-    }
-
-
-    const client = nano(coudhDBSettings);
-    try {
-      if (this.settings.database != null) {
-        await client.db.get(this.settings.database);
-      }
-    } catch (err: any) {
-      if (err.statusCode !== 404) throw err;
-      if (this.settings.database != null) {
-        await client.db.create(this.settings.database);
-      }
-    }
-    if (this.settings.database != null) {
-      this.db = client.use(this.settings.database);
-    }
-  }
-
-  async get(key:string): Promise<null | string> {
-    let doc;
-    try {
-      if (this.db) {
-        doc = await this.db.get(key);
-      }
-    } catch (err:any) {
-      if (err.statusCode === 404) return null;
-      throw err;
-    }
-    if (doc && 'value' in doc) {
-      return doc.value as string;
-    }
-    return '';
-  }
-
-  async findKeys(key:string, notKey:string) {
-    const pfxLen = key.indexOf('*');
-    if (!this.db) {
-      return;
-    }
-    const pfx = pfxLen < 0 ? key : key.slice(0, pfxLen);
-    const results = await this.db.find({
-      selector: {
-        _id: pfxLen < 0 ? pfx : {
-          $gte: pfx,
-          // https://docs.couchdb.org/en/3.2.2/ddocs/views/collation.html#string-ranges
-          $lte: `${pfx}\ufff0`,
-          $regex: this.createFindRegex(key, notKey).source,
-        },
-      },
-      fields: ['_id'],
-    });
-    return results.docs.map((doc) => doc._id);
-  }
-
-  async set(key:string, value:string) {
-    let doc;
-
-    if (!this.db) {
-      return;
-    }
-
-    try {
-      doc = await this.db.get(key);
-    } catch (err:any) {
-      if (err.statusCode !== 404) throw err;
-    }
-    await this.db.insert({
-      _id: key,
-      // @ts-ignore
-      value,
-      ...doc == null ? {} : {
-        _rev: doc._rev,
-      },
-    });
-  }
-
-  async remove(key:string) {
-    let header;
-    if (!this.db) {
-      return;
-    }
-    try {
-      header = await this.db.head(key);
-    } catch (err:any) {
-      if (err.statusCode === 404) return;
-      throw err;
-    }
-    // etag has additional quotation marks, remove them
-    const etag = JSON.parse(header.etag);
-    await this.db.destroy(key, etag);
-  }
-
-  async doBulk(bulk:BulkObject[]) {
-    if (!this.db) {
-      return;
-    }
-    const keys = bulk.map((op) => op.key);
-    const revs:{[key:string]:any} = {};
-    // @ts-ignore
-    for (const {key, value} of (await this.db.fetchRevs({keys})).rows) {
-      // couchDB will return error instead of value if key does not exist
-      if (value != null) revs[key] = value.rev;
-    }
-    const setters = [];
-    for (const item of bulk) {
-      const set = {_id: item.key, _rev: undefined,
-        _deleted: false, value: ''};
-      if (revs[item.key] != null) set._rev = revs[item.key];
-      if (item.type === 'set') set.value = item.value as string;
-      if (item.type === 'remove') set._deleted = true;
-      setters.push(set);
-    }
-    await this.db && await this.db.bulk({docs: setters});
-  }
-
-  async close() {
-    this.db = null;
-    if (this.agent) this.agent.destroy();
-    this.agent = null;
-  }
-};

package/databases/dirty_db.ts

@@ -1,85 +0,0 @@
-/**
- * 2011 Peter 'Pita' Martischka
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS-IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
-*
-* Fair warning that length may not provide the correct value upon load.
-* See https://github.com/ether/etherpad-lite/pull/3984
-*
-*/
-
-import AbstractDatabase, {Settings} from '../lib/AbstractDatabase';
-// @ts-ignore
-import Dirty from 'dirty';
-
-type DirtyDBCallback = (p?:any, keys?: string[])=>{};
-
-
-export const Database = class extends AbstractDatabase {
-  private db: any;
-  constructor(settings:Settings) {
-    super();
-    this.db = null;
-
-    if (!settings || !settings.filename) {
-      // @ts-ignore
-      settings = {filename: null};
-    }
-
-    this.settings = settings;
-
-    // set default settings
-    this.settings.cache = 0;
-    this.settings.writeInterval = 0;
-    this.settings.json = false;
-  }
-
-  init(callback: ()=>{}) {
-    this.db = new Dirty(this.settings.filename);
-    this.db.on('load', (err:string) => {
-      callback();
-    });
-  }
-
-  get(key:string, callback:DirtyDBCallback) {
-    callback(null, this.db.get(key));
-  }
-
-  findKeys(key:string, notKey:string, callback:DirtyDBCallback) {
-    const keys:string[] = [];
-    const regex = this.createFindRegex(key, notKey);
-    this.db.forEach((key:string, val:string) => {
-      if (key.search(regex) !== -1) {
-        keys.push(key);
-      }
-    });
-    callback(null, keys);
-  }
-
-  set(key:string, value:string, callback:DirtyDBCallback) {
-    this.db.set(key, value, callback);
-  }
-
-  remove(key:string, callback:DirtyDBCallback) {
-    this.db.rm(key, callback);
-  }
-
-  close(callback:DirtyDBCallback) {
-    this.db.close();
-    this.db = null;
-    if (callback) callback();
-  }
-};

package/databases/dirty_git_db.ts

@@ -1,82 +0,0 @@
-import AbstractDatabase, {Settings} from '../lib/AbstractDatabase';
-
-/**
- * 2011 Peter 'Pita' Martischka
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS-IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-// @ts-ignore
-import {Dirty} from 'dirty';
-
-export const Database = class extends AbstractDatabase {
-  private db: any;
-  constructor(settings: Settings) {
-    super();
-    // @ts-ignore
-    this.db = null;
-
-    if (!settings || !settings.filename) {
-      settings = {};
-    }
-
-    this.settings = settings;
-
-    // set default settings
-    this.settings.cache = 0;
-    this.settings.writeInterval = 0;
-    this.settings.json = false;
-  }
-
-  init(callback: ()=>void) {
-    this.db = new Dirty(this.settings.filename);
-    this.db.on('load', (err: Error) => {
-      callback();
-    });
-  }
-
-  get(key:string, callback: (err: string | any, value: string)=>void) {
-    callback(null, this.db.get(key));
-  }
-
-  findKeys(key:string, notKey:string, callback:(v:any, keys:string[])=>{}) {
-    const keys:string[] = [];
-    const regex = this.createFindRegex(key, notKey);
-    this.db.forEach((key:string, val:string) => {
-      if (key.search(regex) !== -1) {
-        keys.push(key);
-      }
-    });
-    callback(null, keys);
-  }
-
-  set(key:string, value: string, callback: ()=>{}) {
-    this.db.set(key, value, callback);
-    const databasePath = require('path').dirname(this.settings.filename);
-    require('simple-git')(databasePath)
-        .silent(true)
-        .add('./*.db')
-        .commit('Automated commit...')
-        .push(['-u', 'origin', 'master'], () => console.debug('Stored git commit'));
-  }
-
-  remove(key:string, callback:()=> {}) {
-    this.db.rm(key, callback);
-  }
-
-  close(callback: ()=>void) {
-    this.db.close();
-    if (callback) callback();
-  }
-};