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

Infrascan scanner definition for AWS ECS

// src/generated/getters.ts
import {
  evaluateSelectorGlobally,
  resolveFunctionCallParameters
} from "@infrascan/core";
import {
  ECSServiceException,
  ListClustersCommand,
  DescribeClustersCommand,
  ListServicesCommand,
  DescribeServicesCommand,
  ListTasksCommand,
  DescribeTasksCommand,
  DescribeTaskDefinitionCommand
} from "@aws-sdk/client-ecs";
import debug from "debug";
async function ListClusters(client, stateConnector, context) {
  const getterDebug = debug("ecs:ListClusters");
  const state = [];
  getterDebug("ListClusters");
  const preparedParams = {};
  try {
    const cmd = new ListClustersCommand(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 ECSServiceException) {
      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,
    "ECS",
    "ListClusters",
    state
  );
}
async function DescribeClusters(client, stateConnector, context) {
  const getterDebug = debug("ecs:DescribeClusters");
  const state = [];
  getterDebug("Fetching state");
  const resolvers = [
    {
      Key: "clusters",
      Selector: "ECS|ListClusters|[]._result.clusterArns | [?length(@)>`0`]"
    },
    {
      Key: "include",
      Value: [
        "ATTACHMENTS",
        "SETTINGS",
        "CONFIGURATIONS",
        "STATISTICS",
        "TAGS"
      ]
    }
  ];
  const parameterQueue = await resolveFunctionCallParameters(
    context.account,
    context.region,
    resolvers,
    stateConnector
  );
  for (const parameters of parameterQueue) {
    const preparedParams = parameters;
    try {
      const cmd = new DescribeClustersCommand(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 ECSServiceException) {
        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,
    "ECS",
    "DescribeClusters",
    state
  );
}
async function ListServices(client, stateConnector, context) {
  const getterDebug = debug("ecs:ListServices");
  const state = [];
  getterDebug("Fetching state");
  const resolvers = [
    { Key: "cluster", Selector: "ECS|ListClusters|[]._result.clusterArns[]" },
    { Key: "maxResults", Value: 100 }
  ];
  const parameterQueue = await resolveFunctionCallParameters(
    context.account,
    context.region,
    resolvers,
    stateConnector
  );
  for (const parameters of parameterQueue) {
    const preparedParams = parameters;
    try {
      const cmd = new ListServicesCommand(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 ECSServiceException) {
        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,
    "ECS",
    "ListServices",
    state
  );
}
async function DescribeServices(client, stateConnector, context) {
  const getterDebug = debug("ecs:DescribeServices");
  const state = [];
  getterDebug("Fetching state");
  const resolvers = [
    { Key: "cluster", Selector: "ECS|ListServices|[]._parameters.cluster" },
    {
      Key: "services",
      Selector: "ECS|ListServices|[]._result.serviceArns | [?length(@)>`0`]"
    },
    { Key: "include", Value: ["TAGS"] }
  ];
  const parameterQueue = await resolveFunctionCallParameters(
    context.account,
    context.region,
    resolvers,
    stateConnector
  );
  for (const parameters of parameterQueue) {
    const preparedParams = parameters;
    try {
      const cmd = new DescribeServicesCommand(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 ECSServiceException) {
        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,
    "ECS",
    "DescribeServices",
    state
  );
}
async function ListTasks(client, stateConnector, context) {
  const getterDebug = debug("ecs:ListTasks");
  const state = [];
  getterDebug("Fetching state");
  const resolvers = [
    { Key: "cluster", Selector: "ECS|ListClusters|[]._result.clusterArns[]" }
  ];
  const parameterQueue = await resolveFunctionCallParameters(
    context.account,
    context.region,
    resolvers,
    stateConnector
  );
  for (const parameters of parameterQueue) {
    const preparedParams = parameters;
    try {
      const cmd = new ListTasksCommand(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 ECSServiceException) {
        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,
    "ECS",
    "ListTasks",
    state
  );
}
async function DescribeTasks(client, stateConnector, context) {
  const getterDebug = debug("ecs:DescribeTasks");
  const state = [];
  getterDebug("Fetching state");
  const resolvers = [
    { Key: "cluster", Selector: "ECS|ListTasks|[]._parameters.cluster" },
    {
      Key: "tasks",
      Selector: "ECS|ListTasks|[]._result.taskArns | [?length(@)>`0`]"
    }
  ];
  const parameterQueue = await resolveFunctionCallParameters(
    context.account,
    context.region,
    resolvers,
    stateConnector
  );
  for (const parameters of parameterQueue) {
    const preparedParams = parameters;
    try {
      const cmd = new DescribeTasksCommand(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 ECSServiceException) {
        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,
    "ECS",
    "DescribeTasks",
    state
  );
}
async function DescribeTaskDefinition(client, stateConnector, context) {
  const getterDebug = debug("ecs:DescribeTaskDefinition");
  const state = [];
  getterDebug("Fetching state");
  const resolvers = [
    {
      Key: "taskDefinition",
      Selector: "ECS|DescribeTasks|[]._result.tasks[].taskDefinitionArn"
    },
    { Key: "include", Value: ["TAGS"] }
  ];
  const parameterQueue = await resolveFunctionCallParameters(
    context.account,
    context.region,
    resolvers,
    stateConnector
  );
  for (const parameters of parameterQueue) {
    const preparedParams = parameters;
    try {
      const cmd = new DescribeTaskDefinitionCommand(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 ECSServiceException) {
        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,
    "ECS",
    "DescribeTaskDefinition",
    state
  );
}
async function getIamRoles(stateConnector) {
  const iamDebug = debug("ecs:iam");
  iamDebug("Pulling IAM roles from state");
  const state = [];
  const DescribeTaskDefinitionRoleState = await evaluateSelectorGlobally(
    "ECS|DescribeTaskDefinition|[]._result.taskDefinition | [].{roleArn:taskRoleArn,executor:taskDefinitionArn}",
    stateConnector
  );
  state.push(...DescribeTaskDefinitionRoleState);
  const DescribeTaskDefinitionRoleState1 = await evaluateSelectorGlobally(
    "ECS|DescribeTaskDefinition|[]._result.taskDefinition | [].{roleArn:executionRoleArn,executor:taskDefinitionArn}",
    stateConnector
  );
  state.push(...DescribeTaskDefinitionRoleState1);
  return state;
}
export {
  DescribeClusters,
  DescribeServices,
  DescribeTaskDefinition,
  DescribeTasks,
  ListClusters,
  ListServices,
  ListTasks,
  getIamRoles
};