Added support for multiple kafka clusters

plugins/kafka-backend/README.md

@@ -23,6 +23,8 @@ Example:
 ```yaml
 kafka:
   clientId: backstage
-  brokers:
-    - localhost:9092
+  clusters:
+    name: prod
+    brokers:
+      - localhost:9092
 ```

plugins/kafka-backend/config.d.ts

@@ -16,11 +16,14 @@
 export interface Config {
   kafka?: {
     clientId: string;
-    brokers: string[];
-    ssl?: {
-      ca: string[];
-      key: string;
-      cert: string;
-    };
+    clusters: {
+      name: string;
+      brokers: string[];
+      ssl?: {
+        ca: string[];
+        key: string;
+        cert: string;
+      };
+    }[];
   };
 }

plugins/kafka-backend/src/config/ClusterReader.test.ts

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * 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 '@backstage/backend-common';
+import { ConfigReader } from '@backstage/config';
+import { getClusterDetails } from './ClusterReader';
+
+describe('getClusterDetails', () => {
+  it('empty clusters return empty cluster details', async () => {
+    const config = new ConfigReader({ clusters: [] });
+
+    const result = getClusterDetails(config.getConfigArray('clusters'));
+
+    expect(result).toStrictEqual([]);
+  });
+
+  it('two clusters return two cluster details', async () => {
+    const config = new ConfigReader({
+      clusters: [
+        { name: 'cluster1', brokers: ['a', 'b'] },
+        { name: 'cluster2', brokers: ['d'] },
+      ],
+    });
+
+    const result = getClusterDetails(config.getConfigArray('clusters'));
+
+    expect(result).toStrictEqual([
+      { name: 'cluster1', brokers: ['a', 'b'] },
+      { name: 'cluster2', brokers: ['d'] },
+    ]);
+  });
+});

plugins/kafka-backend/src/config/ClusterReader.ts

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * 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 { Config } from '@backstage/config';
+import { ConnectionOptions } from 'tls';
+import { ClusterDetails } from '../types/types';
+
+export function getClusterDetails(config: Config[]): ClusterDetails[] {
+  return config.map(clusterConfig => {
+    const clusterDetails = {
+      name: clusterConfig.getString('name'),
+      brokers: clusterConfig.getStringArray('brokers'),
+    };
+    const sslConfig = clusterConfig.getOptional('kafka.ssl');
+    if (sslConfig) {
+      return {
+        ...clusterDetails,
+        ssl: sslConfig as ConnectionOptions,
+      };
+    }
+
+    return clusterDetails;
+  });
+}

plugins/kafka-backend/src/service/router.test.ts

@@ -16,22 +16,34 @@
 
 import request from 'supertest';
 import express from 'express';
-import { makeRouter } from './router';
+import { makeRouter, ClusterApi } from './router';
 import { getVoidLogger } from '@backstage/backend-common';
 import { KafkaApi } from './KafkaApi';
 import { when } from 'jest-when';
 
 describe('router', () => {
   let app: express.Express;
-  let kafkaApi: jest.Mocked<KafkaApi>;
+  let apis: ClusterApi[];
+  let devKafkaApi: jest.Mocked<KafkaApi>;
+  let prodKafkaApi: jest.Mocked<KafkaApi>;
 
   beforeAll(async () => {
-    kafkaApi = {
+    devKafkaApi = {
       fetchTopicOffsets: jest.fn(),
       fetchGroupOffsets: jest.fn(),
     };
 
-    const router = makeRouter(getVoidLogger(), kafkaApi);
+    prodKafkaApi = {
+      fetchTopicOffsets: jest.fn(),
+      fetchGroupOffsets: jest.fn(),
+    };
+
+    apis = [
+      { name: 'dev', api: devKafkaApi },
+      { name: 'prod', api: prodKafkaApi },
+    ];
+
+    const router = makeRouter(getVoidLogger(), apis);
     app = express().use(router);
   });
 
@@ -39,7 +51,7 @@ describe('router', () => {
     jest.resetAllMocks();
   });
 
-  describe('get /consumer/:consumerId/offsets', () => {
+  describe('get /:clusterId/consumer/:consumerId/offsets', () => {
     it('returns topic and group offsets', async () => {
       const topic1Offsets = [
         { id: 1, offset: '500' },
@@ -60,15 +72,17 @@ describe('router', () => {
           partitions: [{ id: 1, offset: '456' }],
         },
       ];
-      when(kafkaApi.fetchTopicOffsets)
+      when(prodKafkaApi.fetchTopicOffsets)
         .calledWith('topic1')
         .mockResolvedValue(topic1Offsets);
-      when(kafkaApi.fetchTopicOffsets)
+      when(prodKafkaApi.fetchTopicOffsets)
         .calledWith('topic2')
         .mockResolvedValue(topic2Offsets);
-      kafkaApi.fetchGroupOffsets.mockResolvedValue(groupOffsets);
+      when(prodKafkaApi.fetchGroupOffsets)
+        .calledWith('hey')
+        .mockResolvedValue(groupOffsets);
 
-      const response = await request(app).get('/consumer/hey/offsets');
+      const response = await request(app).get('/prod/consumer/hey/offsets');
 
       expect(response.status).toEqual(200);
       expect(response.body.consumerId).toEqual('hey');
@@ -95,11 +109,64 @@ describe('router', () => {
     });
 
     it('handles internal error correctly', async () => {
-      kafkaApi.fetchGroupOffsets.mockRejectedValue(Error('oh no'));
+      prodKafkaApi.fetchGroupOffsets.mockRejectedValue(Error('oh no'));
 
-      const response = await request(app).get('/consumer/hey/offsets');
+      const response = await request(app).get('/prod/consumer/hey/offsets');
 
       expect(response.status).toEqual(500);
     });
+
+    it('uses correct kafka cluster', async () => {
+      const topic1ProdOffsets = [{ id: 1, offset: '500' }];
+      const topic1DevOffsets = [{ id: 1, offset: '1234' }];
+      const groupProdOffsets = [
+        {
+          topic: 'topic1',
+          partitions: [{ id: 1, offset: '100' }],
+        },
+      ];
+      const groupDevOffsets = [
+        {
+          topic: 'topic1',
+          partitions: [{ id: 1, offset: '567' }],
+        },
+      ];
+      when(prodKafkaApi.fetchTopicOffsets)
+        .calledWith('topic1')
+        .mockResolvedValue(topic1ProdOffsets);
+      when(prodKafkaApi.fetchGroupOffsets)
+        .calledWith('hey')
+        .mockResolvedValue(groupProdOffsets);
+      when(devKafkaApi.fetchTopicOffsets)
+        .calledWith('topic1')
+        .mockResolvedValue(topic1DevOffsets);
+      when(devKafkaApi.fetchGroupOffsets)
+        .calledWith('hey')
+        .mockResolvedValue(groupDevOffsets);
+
+      const prodResponse = await request(app).get('/prod/consumer/hey/offsets');
+      const devResponse = await request(app).get('/dev/consumer/hey/offsets');
+
+      expect(prodResponse.status).toEqual(200);
+      expect(prodResponse.body.consumerId).toEqual('hey');
+      expect(prodResponse.body.offsets).toIncludeSameMembers([
+        {
+          topic: 'topic1',
+          partitionId: 1,
+          groupOffset: '100',
+          topicOffset: '500',
+        },
+      ]);
+      expect(devResponse.status).toEqual(200);
+      expect(devResponse.body.consumerId).toEqual('hey');
+      expect(devResponse.body.offsets).toIncludeSameMembers([
+        {
+          topic: 'topic1',
+          partitionId: 1,
+          groupOffset: '567',
+          topicOffset: '1234',
+        },
+      ]);
+    });
   });
 });

plugins/kafka-backend/src/service/router.ts

@@ -20,31 +20,43 @@ import { Logger } from 'winston';
 import { Config } from '@backstage/config';
 import { KafkaApi, KafkaJsApiImpl } from './KafkaApi';
 import _ from 'lodash';
-import { ConnectionOptions } from 'tls';
+import { getClusterDetails } from '../config/clusterReader';
 
 export interface RouterOptions {
   logger: Logger;
   config: Config;
 }
 
+export interface ClusterApi {
+  name: string;
+  api: KafkaApi;
+}
+
 export const makeRouter = (
   logger: Logger,
-  kafkaApi: KafkaApi,
+  kafkaApis: ClusterApi[],
 ): express.Router => {
   const router = Router();
   router.use(express.json());
 
-  router.get('/consumer/:consumerId/offsets', async (req, res) => {
+  const kafkaApiByClusterName = _.keyBy(kafkaApis, item => item.name);
+
+  router.get('/consumers/:clusterId/:consumerId/offsets', async (req, res) => {
+    const clusterId = req.params.clusterId;
     const consumerId = req.params.consumerId;
 
-    logger.debug(`Fetch consumer group ${consumerId} offsets`);
+    logger.info(
+      `Fetch consumer group ${consumerId} offsets from cluster ${clusterId}`,
+    );
 
-    const groupOffsets = await kafkaApi.fetchGroupOffsets(consumerId);
+    const kafkaApi = kafkaApiByClusterName[clusterId];
+
+    const groupOffsets = await kafkaApi.api.fetchGroupOffsets(consumerId);
 
     const groupWithTopicOffsets = await Promise.all(
       groupOffsets.map(async ({ topic, partitions }) => {
         const topicOffsets = _.keyBy(
-          await kafkaApi.fetchTopicOffsets(topic),
+          await kafkaApi.api.fetchTopicOffsets(topic),
           partition => partition.id,
         );
 
@@ -70,12 +82,15 @@ export async function createRouter(
   logger.info('Initializing Kafka backend');
 
   const clientId = options.config.getString('kafka.clientId');
-  const brokers = options.config.getStringArray('kafka.brokers');
 
-  const sslConfig = options.config.getOptional('kafka.ssl');
-  const ssl = sslConfig ? (sslConfig as ConnectionOptions) : undefined;
+  const clusters = getClusterDetails(
+    options.config.getConfigArray('kafka.clusters'),
+  );
 
-  const kafkaApi = new KafkaJsApiImpl({ clientId, brokers, logger, ssl });
+  const kafkaApis = clusters.map(cluster => ({
+    name: cluster.name,
+    api: new KafkaJsApiImpl({ clientId, logger, ...cluster }),
+  }));
 
-  return makeRouter(logger, kafkaApi);
+  return makeRouter(logger, kafkaApis);
 }

plugins/kafka-backend/src/types/types.ts

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2020 Spotify AB
+ *
+ * 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 { ConnectionOptions } from 'tls';
+
+export interface ClusterDetails {
+  name: string;
+  brokers: string[];
+  ssl?: ConnectionOptions;
+}