feat(datasource): add eks addon datasource

lib/modules/datasource/api.ts

@@ -1,4 +1,5 @@
 import { ArtifactoryDatasource } from './artifactory';
+import { AwsEKSAddonDataSource } from './aws-eks-addon';
 import { AwsMachineImageDatasource } from './aws-machine-image';
 import { AwsRdsDatasource } from './aws-rds';
 import { AzureBicepResourceDatasource } from './azure-bicep-resource';
@@ -70,6 +71,7 @@ const api = new Map<string, DatasourceApi>();
 export default api;
 
 api.set(ArtifactoryDatasource.id, new ArtifactoryDatasource());
+api.set(AwsEKSAddonDataSource.id, new AwsEKSAddonDataSource());
 api.set(AwsMachineImageDatasource.id, new AwsMachineImageDatasource());
 api.set(AwsRdsDatasource.id, new AwsRdsDatasource());
 api.set(AzureBicepResourceDatasource.id, new AzureBicepResourceDatasource());

lib/modules/datasource/aws-eks-addon/index.spec.ts

@@ -0,0 +1,264 @@
+import {
+  type AddonInfo,
+  DescribeAddonVersionsCommand,
+  type DescribeAddonVersionsResponse,
+  EKSClient,
+} from '@aws-sdk/client-eks';
+import { mockClient } from 'aws-sdk-client-mock';
+import { getPkgReleases } from '..';
+import { logger } from '../../../../test/util';
+
+import { AwsEKSAddonDataSource } from '.';
+
+const datasource = AwsEKSAddonDataSource.id;
+const eksMock = mockClient(EKSClient);
+
+function mockDescribeAddonVersionsCommand(
+  result: DescribeAddonVersionsResponse,
+): void {
+  eksMock.reset();
+  eksMock.on(DescribeAddonVersionsCommand).resolves(result);
+}
+
+function mockDescribeAddonVersionsCommandWithRegion(
+  result: DescribeAddonVersionsResponse,
+): void {
+  eksMock.reset();
+  eksMock
+    .on(DescribeAddonVersionsCommand)
+    .callsFake(async (input, getClient) => {
+      const client = getClient();
+      const region = await client.config.region();
+      return {
+        ...result,
+        // put the client region as nextToken
+        // so that when we assert on the snapshot, we also verify that region from packageName is
+        // passed to aws client.
+        nextToken: region,
+      };
+    });
+}
+
+const addonInfo: AddonInfo = {
+  addonName: 'vpc-cni',
+  type: 'networking',
+  addonVersions: [
+    {
+      addonVersion: 'v1.19.0-eksbuild.1',
+      architecture: ['amd64', 'arm64'],
+      compatibilities: [
+        {
+          clusterVersion: '1.31',
+          defaultVersion: true,
+        },
+        {
+          clusterVersion: '1.30',
+          defaultVersion: true,
+        },
+        {
+          clusterVersion: '1.29',
+          defaultVersion: true,
+        },
+      ],
+    },
+    {
+      addonVersion: 'v1.18.1-eksbuild.1',
+      architecture: ['amd64', 'arm64'],
+      compatibilities: [
+        {
+          clusterVersion: '1.30',
+          defaultVersion: false,
+        },
+      ],
+    },
+    {
+      addonVersion: 'v1.18.2-eksbuild.1',
+      architecture: ['amd64', 'arm64'],
+      compatibilities: [
+        {
+          clusterVersion: '1.30',
+          platformVersions: ['*'],
+          defaultVersion: true,
+        },
+      ],
+    },
+  ],
+  publisher: 'eks',
+  owner: 'aws',
+};
+
+describe('modules/datasource/aws-eks-addon/index', () => {
+  describe('getPkgReleases()', () => {
+    it.each<{ des: string; req: DescribeAddonVersionsResponse }>`
+      des               | req
+      ${'null'}         | ${{}}
+      ${'empty'}        | ${{ addons: [] }}
+      ${'emptyVersion'} | ${{ addons: [{}] }}
+    `('returned $des addons to be null', async ({ req }) => {
+      mockDescribeAddonVersionsCommand(req);
+      const res = await getPkgReleases({
+        datasource,
+        packageName:
+          '{"kubernetesVersion":"1.30","addonName":"non-existing-addon"}',
+      });
+      expect(res).toBeNull();
+      expect(eksMock.calls()).toHaveLength(1);
+      expect(eksMock.call(0).args[0].input).toEqual({
+        kubernetesVersion: '1.30',
+        addonName: 'non-existing-addon',
+        maxResults: 1,
+      });
+    });
+
+    it('with addonName not supplied', async () => {
+      const res = await getPkgReleases({
+        datasource,
+        packageName: '{"kubernetesVersion":"1.30"}',
+      });
+      expect(res).toBeNull();
+      expect(logger.logger.error).toHaveBeenCalledTimes(1);
+    });
+
+    it('with addonName only', async () => {
+      mockDescribeAddonVersionsCommand({ addons: [addonInfo] });
+      const res = await getPkgReleases({
+        datasource,
+        packageName: '{"addonName":"vpc-cni"}',
+      });
+      expect(res?.releases).toHaveLength(3);
+      expect(res).toEqual({
+        releases: [
+          {
+            version: 'v1.18.1-eksbuild.1',
+            compatibleWith: ['1.30'],
+            default: false,
+          },
+          {
+            version: 'v1.18.2-eksbuild.1',
+            compatibleWith: ['1.30'],
+            default: true,
+          },
+          {
+            version: 'v1.19.0-eksbuild.1',
+            compatibleWith: ['1.31', '1.30', '1.29'],
+            default: true,
+          },
+        ],
+      });
+      expect(eksMock.call(0).args[0].input).toEqual({
+        addonName: 'vpc-cni',
+        maxResults: 1,
+      });
+    });
+
+    it('with addon and profile', async () => {
+      mockDescribeAddonVersionsCommand({ addons: [] });
+      await getPkgReleases({
+        datasource,
+        packageName: '{"addonName":"vpc-cni-not-exist", "profile":"paradox"}',
+      });
+      expect(eksMock.calls()).toHaveLength(1);
+    });
+
+    it('with addon and region', async () => {
+      mockDescribeAddonVersionsCommand({ addons: [] });
+      await getPkgReleases({
+        datasource,
+        packageName: '{"addonName":"vpc-cni-not-exist", "region":"usa"}',
+      });
+      expect(eksMock.calls()).toHaveLength(1);
+    });
+
+    it('with addonName and default only config', async () => {
+      mockDescribeAddonVersionsCommand({ addons: [addonInfo] });
+      const res = await getPkgReleases({
+        datasource,
+        packageName: '{"addonName":"vpc-cni", "default":true}',
+      });
+      expect(eksMock.call(0).args[0].input).toEqual({
+        addonName: 'vpc-cni',
+        maxResults: 1,
+      });
+      expect(res?.releases).toHaveLength(2);
+      expect(res).toEqual({
+        releases: [
+          {
+            version: 'v1.18.2-eksbuild.1',
+            compatibleWith: ['1.30'],
+            default: true,
+          },
+          {
+            version: 'v1.19.0-eksbuild.1',
+            compatibleWith: ['1.31', '1.30', '1.29'],
+            default: true,
+          },
+        ],
+      });
+    });
+
+    it('with matched addon to return all versions of the addon', async () => {
+      const vpcCniAddonInfo: AddonInfo = {
+        addonName: 'vpc-cni',
+        type: 'networking',
+        addonVersions: [
+          {
+            addonVersion: 'v1.18.1-eksbuild.1',
+            architecture: ['amd64', 'arm64'],
+            compatibilities: [
+              {
+                clusterVersion: '1.30',
+                platformVersions: ['*'],
+                defaultVersion: false,
+              },
+            ],
+            requiresConfiguration: false,
+          },
+          {
+            addonVersion: 'v1.18.2-eksbuild.1',
+            architecture: ['amd64', 'arm64'],
+            compatibilities: [
+              {
+                clusterVersion: '1.30',
+                platformVersions: ['*'],
+                defaultVersion: false,
+              },
+            ],
+            requiresConfiguration: false,
+          },
+          // a bad addonVersion that's missing the basic fields.
+          {},
+        ],
+        publisher: 'eks',
+        owner: 'aws',
+      };
+
+      mockDescribeAddonVersionsCommandWithRegion({
+        addons: [vpcCniAddonInfo],
+      });
+      const res = await getPkgReleases({
+        datasource,
+        packageName:
+          '{"kubernetesVersion":"1.30","addonName":"vpc-cni","region":"mars-east-1"}',
+      });
+      expect(res).toEqual({
+        releases: [
+          {
+            version: 'v1.18.1-eksbuild.1',
+            compatibleWith: ['1.30'],
+            default: false,
+          },
+          {
+            version: 'v1.18.2-eksbuild.1',
+            compatibleWith: ['1.30'],
+            default: false,
+          },
+        ],
+      });
+      expect(eksMock.call(0).args[0].input).toEqual({
+        kubernetesVersion: '1.30',
+        addonName: 'vpc-cni',
+        maxResults: 1,
+      });
+    });
+  });
+});

lib/modules/datasource/aws-eks-addon/index.ts

@@ -0,0 +1,96 @@
+import {
+  type AddonInfo,
+  type AddonVersionInfo,
+  type Compatibility,
+  DescribeAddonVersionsCommand,
+  type DescribeAddonVersionsCommandInput,
+  type DescribeAddonVersionsCommandOutput,
+  EKSClient,
+} from '@aws-sdk/client-eks';
+import { fromNodeProviderChain } from '@aws-sdk/credential-providers';
+import { logger } from '../../../logger';
+import { cache } from '../../../util/cache/package/decorator';
+// import * as awsEksAddonVersioning from '../../versioning/aws-eks-addon';
+import { Datasource } from '../datasource';
+import type { GetReleasesConfig, ReleaseResult } from '../types';
+import { EksAddonsFilter } from './schema';
+
+export class AwsEKSAddonDataSource extends Datasource {
+  static readonly id = 'aws-eks-addon';
+
+  // override readonly defaultVersioning = awsEksAddonVersioning.id;
+  override readonly caching = true;
+  private readonly clients: Record<string, EKSClient> = {};
+
+  override readonly defaultConfig: Record<string, unknown> | undefined = {
+    commitMessageTopic: '{{datasource}}',
+    commitMessageExtra: '{{currentVersion}} to {{{newVersion}}}',
+  };
+
+  constructor() {
+    super(AwsEKSAddonDataSource.id);
+  }
+
+  @cache({
+    namespace: `datasource-${AwsEKSAddonDataSource.id}`,
+    key: ({ packageName }: GetReleasesConfig) => `getReleases:${packageName}`,
+  })
+  async getReleases({
+    packageName: serializedFilter,
+  }: GetReleasesConfig): Promise<ReleaseResult | null> {
+    const res = EksAddonsFilter.safeParse(serializedFilter);
+    if (!res.success) {
+      logger.error(
+        { err: res.error, serializedFilter },
+        'Error parsing eks-addons config.',
+      );
+      return null;
+    }
+
+    const filter = res.data;
+    const input: DescribeAddonVersionsCommandInput = {
+      kubernetesVersion: filter?.kubernetesVersion,
+      addonName: filter?.addonName,
+      maxResults: 1,
+    };
+
+    const cmd = new DescribeAddonVersionsCommand(input);
+    const response: DescribeAddonVersionsCommandOutput =
+      await this.getClient(filter).send(cmd);
+    const addons: AddonInfo[] = response.addons ?? [];
+    return {
+      releases: addons
+        .flatMap((addon: AddonInfo): AddonVersionInfo[] | undefined => {
+          return addon.addonVersions;
+        })
+        .map((versionInfo: AddonVersionInfo | undefined) => ({
+          version: versionInfo?.addonVersion ?? '',
+          default:
+            versionInfo?.compatibilities?.some(
+              (comp: Compatibility): boolean | undefined => comp.defaultVersion,
+            ) ?? false,
+          compatibleWith: versionInfo?.compatibilities?.flatMap(
+            (comp: Compatibility): string | undefined => comp.clusterVersion,
+          ),
+        }))
+        .filter((release) => release.version && release.version !== '')
+        .filter((release): boolean => {
+          if (filter.default) {
+            return release.default && release.default === filter.default;
+          }
+          return true;
+        }),
+    };
+  }
+
+  private getClient({ region, profile }: EksAddonsFilter): EKSClient {
+    const cacheKey = `${region ?? 'default'}#${profile ?? 'default'}`;
+    if (!(cacheKey in this.clients)) {
+      this.clients[cacheKey] = new EKSClient({
+        region: region ?? undefined,
+        credentials: fromNodeProviderChain(profile ? { profile } : undefined),
+      });
+    }
+    return this.clients[cacheKey];
+  }
+}