: app.listen(listen_port, () => {
            logger.info('%s listening at %s', app.name, app.url);

            if (onServerStart != null)
                return onServerStart(app.url, app, orms_out,
                    callback == null ? /* tslint:disable:no-empty*/ () => {} : callback
                );
            else if (callback != null)
                return callback(null, app, orms_out);
        });

  public start () {
    if (this.options.webhookProxy) {
      createWebhookProxy({
        logger,
        path: this.options.webhookPath,
        port: this.options.port,
        url: this.options.webhookProxy,
      })
    }

    this.server.listen(this.options.port)
    logger.info('Listening on http://localhost:' + this.options.port)
  }

    waterline_obj.initialize(orm.config, (err, ontology) => {
        if (err != null)
            return callback(err);
        else if (ontology == null || ontology.connections == null || ontology.collections == null
            || ontology.connections.length === 0 || ontology.collections.length === 0) {
            logger.error('waterline_obj.initialize::ontology =', ontology, ';');
            return callback(new TypeError('Expected ontology with connections & waterline_collections'));
        }

        // Tease out fully initialised models.
        logger.info('Waterline initialised with:\t', Object.keys(ontology.collections), ';');
        return callback(null, { connection: ontology.connections, collections: ontology.collections });
    });

const sequelizeHandler = (orm: {skip: boolean, uri?: string, config?: sequelize.Options, map: Map<string, any>},
                          logger: Logger, callback: (err, ...args) => void) => {
    if (orm.skip) return callback(void 0);

    logger.info('Sequelize initialising with:\t', Array.from(orm.map.keys()), ';');
    const sequelize_obj: sequelize.Sequelize = new sequelize['Sequelize'](orm.uri, orm.config);

    const entities = new Map<string, sequelize.Instance<{}> & sequelize.Model<{}, {}>>();
    for (const [entity, program] of orm.map)
        entities.set(entity, program(sequelize_obj, orm.map));

    sequelize_obj
        .authenticate()
        .then(() => map(
            Array.from(entities.keys()),
            (entity_name, cb) =>
                sequelize_obj
                    .sync(entities.get(entity_name) as any)
                    .then(_ => cb(void 0))
                    .catch(cb),
            err => callback(err, { connection: sequelize_obj, entities })
        ))
        .catch(callback);
};

export default async function tweetImage(logger: Logger) {
  try {
    const { fileName, file } = await getRandomPicture();

    const b64Picture = file.toString('base64');
    const uploadedPicture = await t.post('media/upload', {
      stringify_ids: true,
      media_data: b64Picture,
    });
    const mediaParams = {
      stringify_ids: true,
      // @ts-ignore
      media_id: uploadedPicture.data.media_id_string,
      alt_text,
    };

    await t.post('media/metadata/create', mediaParams);
    const tweet = await t.post('statuses/update', {
      stringify_ids: true,
      status: config.twitter.tweetMessage,
      // @ts-ignore
      media_ids: [uploadedPicture.data.media_id_string],
    });

    logger.info({
      status: config.twitter.tweetMessage,
      // @ts-ignore
      mediaIds: uploadedPicture.data.media_id_string,
      image: fileName,
      // @ts-ignore
      tweet: tweet.data.id_str,
    });
  } catch (e) {
    logger.error(e);
  }
}