@infrascan/aws-kinesis-scanner/dist/generated/getters.mjs

Infrascan scanner definition for AWS Kinesis

// src/generated/getters.ts
import { resolveFunctionCallParameters } from "@infrascan/core";
import {
  KinesisServiceException,
  ListStreamsCommand,
  DescribeStreamSummaryCommand,
  ListStreamConsumersCommand
} from "@aws-sdk/client-kinesis";
import debug from "debug";
async function ListStreams(client, stateConnector, context) {
  const getterDebug = debug("kinesis:ListStreams");
  const state = [];
  getterDebug("Fetching state");
  let pagingToken;
  do {
    const preparedParams = {};
    preparedParams.NextToken = pagingToken;
    try {
      const cmd = new ListStreamsCommand(preparedParams);
      const result = await client.send(cmd);
      state.push({
        _metadata: {
          account: context.account,
          region: context.region,
          timestamp: Date.now()
        },
        _parameters: preparedParams,
        _result: result
      });
      pagingToken = result.NextToken;
      if (pagingToken != null) {
        getterDebug("Found pagination token in response");
      } else {
        getterDebug("No pagination token found in response");
      }
    } catch (err) {
      if (err instanceof KinesisServiceException) {
        if (err?.$retryable) {
          console.log("Encountered retryable error", err);
        } else {
          console.log("Encountered unretryable error", err);
        }
      } else {
        console.log("Encountered unexpected error", err);
      }
      pagingToken = void 0;
    }
  } while (pagingToken != null);
  getterDebug("Recording state");
  await stateConnector.onServiceScanCompleteCallback(
    context.account,
    context.region,
    "Kinesis",
    "ListStreams",
    state
  );
}
async function DescribeStreamSummary(client, stateConnector, context) {
  const getterDebug = debug("kinesis:DescribeStreamSummary");
  const state = [];
  getterDebug("Fetching state");
  const resolvers = [
    {
      Key: "StreamARN",
      Selector: "Kinesis|ListStreams|[]._result.StreamSummaries[].StreamARN"
    }
  ];
  const parameterQueue = await resolveFunctionCallParameters(
    context.account,
    context.region,
    resolvers,
    stateConnector
  );
  for (const parameters of parameterQueue) {
    const preparedParams = parameters;
    try {
      const cmd = new DescribeStreamSummaryCommand(preparedParams);
      const result = await client.send(cmd);
      state.push({
        _metadata: {
          account: context.account,
          region: context.region,
          timestamp: Date.now()
        },
        _parameters: preparedParams,
        _result: result
      });
    } catch (err) {
      if (err instanceof KinesisServiceException) {
        if (err?.$retryable) {
          console.log("Encountered retryable error", err);
        } else {
          console.log("Encountered unretryable error", err);
        }
      } else {
        console.log("Encountered unexpected error", err);
      }
    }
  }
  getterDebug("Recording state");
  await stateConnector.onServiceScanCompleteCallback(
    context.account,
    context.region,
    "Kinesis",
    "DescribeStreamSummary",
    state
  );
}
async function ListStreamConsumers(client, stateConnector, context) {
  const getterDebug = debug("kinesis:ListStreamConsumers");
  const state = [];
  getterDebug("Fetching state");
  const resolvers = [
    {
      Key: "StreamARN",
      Selector: "Kinesis|ListStreams|[]._result.StreamSummaries[].StreamARN"
    }
  ];
  const parameterQueue = await resolveFunctionCallParameters(
    context.account,
    context.region,
    resolvers,
    stateConnector
  );
  for (const parameters of parameterQueue) {
    let pagingToken;
    do {
      const preparedParams = parameters;
      preparedParams.NextToken = pagingToken;
      try {
        const cmd = new ListStreamConsumersCommand(preparedParams);
        const result = await client.send(cmd);
        state.push({
          _metadata: {
            account: context.account,
            region: context.region,
            timestamp: Date.now()
          },
          _parameters: preparedParams,
          _result: result
        });
        pagingToken = result.NextToken;
        if (pagingToken != null) {
          getterDebug("Found pagination token in response");
        } else {
          getterDebug("No pagination token found in response");
        }
      } catch (err) {
        if (err instanceof KinesisServiceException) {
          if (err?.$retryable) {
            console.log("Encountered retryable error", err);
          } else {
            console.log("Encountered unretryable error", err);
          }
        } else {
          console.log("Encountered unexpected error", err);
        }
        pagingToken = void 0;
      }
    } while (pagingToken != null);
  }
  getterDebug("Recording state");
  await stateConnector.onServiceScanCompleteCallback(
    context.account,
    context.region,
    "Kinesis",
    "ListStreamConsumers",
    state
  );
}
export {
  DescribeStreamSummary,
  ListStreamConsumers,
  ListStreams
};