@infrascan/aws-kinesis-scanner
Version:
Infrascan scanner definition for AWS Kinesis
360 lines (355 loc) • 9.38 kB
JavaScript
// src/generated/client.ts
import { KinesisClient } from "@aws-sdk/client-kinesis";
import debug from "debug";
var clientDebug = debug("kinesis:client");
function getClient(credentials, context, retryStrategy) {
clientDebug("Creating instance with context", context);
return new KinesisClient({
credentials,
region: context.region,
retryStrategy
});
}
// src/generated/getters.ts
import { resolveFunctionCallParameters } from "@infrascan/core";
import {
KinesisServiceException,
ListStreamsCommand,
DescribeStreamSummaryCommand,
ListStreamConsumersCommand
} from "@aws-sdk/client-kinesis";
import debug2 from "debug";
async function ListStreams(client, stateConnector, context) {
const getterDebug = debug2("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 ListStreamConsumers(client, stateConnector, context) {
const getterDebug = debug2("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
);
}
// src/generated/graph.ts
import {
evaluateSelectorGlobally,
filterState,
formatEdge
} from "@infrascan/core";
import debug3 from "debug";
var edgesDebug = debug3("kinesis:edges");
async function getEdges(stateConnector) {
edgesDebug("Fetching edges");
const edges = [];
edgesDebug("Evaluating Kinesis|ListStreamConsumers|[]");
const ListStreamConsumersState1 = await evaluateSelectorGlobally(
"Kinesis|ListStreamConsumers|[]",
stateConnector
);
const ListStreamConsumersEdges1 = ListStreamConsumersState1.flatMap(
(state) => {
const source = filterState(state, "_parameters.StreamARN");
const target = filterState(
state,
"_result.Consumers[].{target:ConsumerARN,name:ConsumerName}"
);
if (!target || !source) {
return [];
}
if (Array.isArray(target)) {
return target.map((edgeTarget) => formatEdge(source, edgeTarget));
}
return formatEdge(source, target);
}
);
edgesDebug(
`Evaluated Kinesis|ListStreamConsumers|[]: ${ListStreamConsumersEdges1.length} Edges found`
);
edges.push(...ListStreamConsumersEdges1);
return edges;
}
// src/graph.ts
import { evaluateSelector, toLowerCase } from "@infrascan/core";
var KinesisStreamEntity = {
version: "0.1.0",
debugLabel: "kinesis",
provider: "aws",
command: "ListStreams",
category: "kinesis",
subcategory: "stream",
nodeType: "kinesis-stream",
selector: "Kinesis|DescribeStreamSummary|[]",
getState(state, context) {
return evaluateSelector(
context.account,
context.region,
KinesisStreamEntity.selector,
state
);
},
translate(val) {
if (val._result.StreamDescriptionSummary == null) {
return [];
}
const enrichedDescription = Object.assign(
val._result.StreamDescriptionSummary,
{
$metadata: val._metadata,
$parameters: val._parameters
}
);
return [enrichedDescription];
},
components: {
$metadata(val) {
return {
version: KinesisStreamEntity.version,
timestamp: val.$metadata.timestamp
};
},
$graph(val) {
return {
id: val.StreamARN,
label: val.StreamName,
nodeType: KinesisStreamEntity.nodeType
};
},
$source(val) {
return {
command: KinesisStreamEntity.command,
parameters: val.$parameters
};
},
tenant(val) {
return {
tenantId: val.$metadata.account,
provider: KinesisStreamEntity.provider,
partition: val.$metadata.partition
};
},
location(val) {
return {
code: val.$metadata.region
};
},
resource(val) {
return {
id: val.StreamARN,
name: val.StreamName,
category: KinesisStreamEntity.category,
subcategory: KinesisStreamEntity.subcategory
};
},
audit(val) {
return {
createdAt: val.StreamCreationTimestamp
};
},
kinesis(val) {
return {
stream: {
mode: val.StreamModeDetails?.StreamMode != null ? toLowerCase(val.StreamModeDetails?.StreamMode) : void 0,
status: val.StreamStatus != null ? toLowerCase(val.StreamStatus) : void 0
}
};
},
encryption(val) {
return {
keyId: val.KeyId
};
}
}
};
var KinesisConsumerEntity = {
version: "0.1.0",
debugLabel: "kinesis",
provider: "aws",
command: "ListStreamConsumers",
category: "kinesis",
subcategory: "consumer",
nodeType: "kinesis-consumer",
selector: "Kinesis|ListStreams|[]",
getState(state, context) {
return evaluateSelector(
context.account,
context.region,
KinesisConsumerEntity.selector,
state
);
},
translate(val) {
return (val._result.Consumers ?? []).map(
(stream) => Object.assign(stream, {
$metadata: val._metadata,
$parameters: val._parameters
})
);
},
components: {
$metadata(val) {
return {
version: KinesisConsumerEntity.version,
timestamp: val.$metadata.timestamp
};
},
$graph(val) {
return {
id: val.ConsumerARN,
label: val.ConsumerName,
nodeType: KinesisConsumerEntity.nodeType
};
},
$source(val) {
return {
command: KinesisConsumerEntity.command,
parameters: val.$parameters
};
},
tenant(val) {
return {
tenantId: val.$metadata.account,
provider: KinesisConsumerEntity.provider,
partition: val.$metadata.partition
};
},
location(val) {
return {
code: val.$metadata.region
};
},
resource(val) {
return {
id: val.ConsumerARN,
name: val.ConsumerName,
category: KinesisConsumerEntity.category,
subcategory: KinesisConsumerEntity.subcategory
};
},
audit(val) {
return {
createdAt: val.ConsumerCreationTimestamp
};
},
kinesis(val) {
return {
consumer: {
status: val.ConsumerStatus != null ? toLowerCase(val.ConsumerStatus) : void 0
}
};
}
}
};
// src/index.ts
var KinesisScanner = {
provider: "aws",
service: "kinesis",
key: "Kinesis",
getClient,
callPerRegion: true,
getters: [ListStreams, ListStreamConsumers],
getEdges,
entities: [KinesisConsumerEntity, KinesisStreamEntity]
};
var index_default = KinesisScanner;
export {
index_default as default
};