hiot-kafka/lib/broker/index.js

hiot-app middleware to bootstrap kafka

"use strict";
//const debug = require("debug")("hiot-kafka");
const { Producer, GroupConsumer } = require("no-kafka");
const strategyFactory = require("./strategyFactory");
const createTopics = require("./createTopics");
const logParser = require("./logParser");

class KafkaBroker {
  constructor() {
    this.handlers = {};
    this.connected = false;
  }

  connect(options) {
    this.logger = options.logger;
    this.producer = createProducer(options);

    var connected = this.producer.init();
    var topics = Object.keys(this.handlers);

    if (!topics.length) {
      return connected;
    }

    if (options.createTopics) {
      return connected
        .then(() => createTopics(this.producer.client, topics))
        .then(() => connectConsumer(this, options));
    }

    return connected.then(() => connectConsumer(this, options));
  }

  send(envelope) {
    if (!this.producer) {
      throw new Error(
        "[hiot-kafka] you need to connect to kafka before trying to send message"
      );
    }

    return this.producer.send(toSend(envelope));
  }

  sendBatch(envelopes) {
    if (!this.producer) {
      throw new Error(
        "[hiot-kafka] you need to connect to kafka before trying to send message"
      );
    }

    var letters = envelopes.map(toSend);
    return this.producer.send(letters);
  }

  consume(topic, handler) {
    this.handlers[topic] = handler;
  }

  close() {
    var closed = [];

    if (this.producer) {
      closed.push(this.producer.end());
    }

    if (this.consumer) {
      closed.push(this.consumer.end());
    }

    return Promise.all(closed);
  }

  refresh() {
    if (!this.producer) {
      return Promise.resolve();
    }
    return this.producer.client.updateMetadata();
  }
}

function createProducer(options) {
  return new Producer({
    clientId: "producer-" + options.clientId,
    connectionString: options.connectionString,
    logger: {
      logLevel: 4,
      logFunction: logParser(options.logger),
    },
    retries: {
      attempts: 3,
      delay: 200,
    },
  });
}

function createConsumer(options) {
  var config = {
    groupId: options.groupId,
    clientId: "consumer-" + options.clientId,
    connectionString: options.connectionString,
    logger: {
      logLevel: 4,
      logFunction: logParser(options.logger),
    },
  };

  if (options.startingOffset) {
    config.startingOffset = options.startingOffset;
  }

  return new GroupConsumer(config);
}

function connectConsumer(broker, options) {
  broker.consumer = createConsumer(options);
  var strategies = strategyFactory.create(broker);
  return broker.consumer.init(strategies);
}

function toSend(envelope) {
  return {
    topic: envelope.topic,
    partition: envelope.partition,
    message: {
      value: JSON.stringify(envelope.message.value),
      key: envelope.message.key,
    },
  };
}

module.exports = new KafkaBroker();