pool.end() not working

Hi folks, currently writing integration tests with jest and facing some troubles with closing pool.

Per docs pool can be closed by calling pool.end(), but for me pool still exists.

Please observe code below.

const { Pool } = require('pg');
const logger = {
  info: console.log
};

const connectionString = "the_connection_string";
const dbName = "the_db";

let pool = null;

const initClient = async () => {
  if (!pool) {
    pool = new Pool({
      connectionString: `${connectionString}/${dbName}`,
      max: 1,
      min: 1,
      idleTimeoutMillis: 1000,
    });

    pool.connect((err) => {
      if (err) {
        logger.error(`Can not connect to postgres at host ${connectionString}, ${err.stack}`);
      } else {
        logger.info(`Postgres connected to host: '${connectionString}'`);
      }
    });
  }

  return pool;
};


initClient();

setTimeout(() => {
   pool.end(() => {
      console.log('pool has ended'); // cb never called
});

   /pool.end().then(() => console.log('pool has ended')) // promise never called
}, 5000);

setInterval(() => {
   console.log(pool.ended); // always false.
}, 3000);


module.exports = {
  initClient,
};

So pool created instantly by calling initClient(), after 5 second pool.ended() called, but it’s callback never called. pool.ended always show false.

Am i doing something wrong or any ideas how to close pool?

[charmander]

The pool won’t call the end callback until all the clients have been returned to it (because it can’t close clients it doesn’t own). You need to release the client you acquired with pool.connect:

pool.connect((err, client) => {
  if (err) {
    logger.error(`Can not connect to postgres at host ${connectionString}, ${err.stack}`);
  } else {
    logger.info(`Postgres connected to host: '${connectionString}'`);
    client.release();
  }
});

initClient still mixes async and callbacks in a way that doesn’t make much sense, though.

[Tchoupinax]

Same issue for me, i called the end function on my pool and something happens because pool.ended becomes true after it.

  log: [Function (anonymous)],
  Client: [Function: Client] { Query: [Function: Query] },
  Promise: [Function: Promise],
  _clients: [],
  _idle: [],
  _pendingQueue: [],
  _endCallback: [Function: cb],
  ending: true,
  ended: true

However, mocha tests does not give back terminal control and it comes from postgres… (It works well when no connection has been created).

I called pool.end(), i waited > 1 minute, ended is marked as “ended” but when i stopped Postgres, Node.js process has crashed.

events.js:196
      throw er; // Unhandled 'error' event
      ^

error: terminating connection due to unexpected postmaster exit

It shows that the connection keeps alive.

    _Promise: [Function: Promise],
    _types: TypeOverrides { _types: [Object], text: {}, binary: {} },
    _ending: true,
    _connecting: false,
    _connected: true, <= ????
    _connectionError: false,
    _queryable: false,
    connection: Connection {
      _events: [Object: null prototype],
      _eventsCount: 22,
      _maxListeners: undefined,
      stream: [Socket],
      _keepAlive: false,
      _keepAliveInitialDelayMillis: 0,
      lastBuffer: false,
      lastOffset: 0,
      buffer: null,
      offset: 111,
      encoding: 'utf8',
      parsedStatements: [Object],
      writer: [Object],
      ssl: false,
      _ending: true,
      _mode: 0,
      _emitMessage: false,
      _reader: [Object]
    },
    queryQueue: [],
    binary: false,
    processID: 64,
    secretKey: -2040677091,
    ssl: false,
    _connectionTimeoutMillis: 300000,
    release: [Function (anonymous)],
    activeQuery: null,
    readyForQuery: true,
    hasExecuted: true
  }

It is not the first time i met this problem and i would like to understand…

My pool is created as the following

let postgresql = new pg.Pool({
  ...config.postgres,
  connectionTimeoutMillis: 500,
  Client: pg.NativeClient,
});

// Query function
    return postgresql.connect()
      .then((client) => client.query(args)
        .then((res) => {
          client.release();
          return res;
        })
        .catch((err) => {
          client.release();
          throw err;
        }));