diff --git a/OMICRON_VERSION b/OMICRON_VERSION index a9d80c78a..5d67ec8a9 100644 --- a/OMICRON_VERSION +++ b/OMICRON_VERSION @@ -1 +1 @@ -eeeb429a5a4c3aeff484c50638255f4c4eadc9ba +5342337ca3703fb5011deccc9abc270693d9bdd1 diff --git a/app/api/__generated__/Api.ts b/app/api/__generated__/Api.ts index 8286832a4..432198927 100644 --- a/app/api/__generated__/Api.ts +++ b/app/api/__generated__/Api.ts @@ -149,6 +149,87 @@ export type AddressLotResultsPage = { nextPage?: string } +/** + * Describes the scope of affinity for the purposes of co-location. + */ +export type FailureDomain = 'sled' + +/** + * Affinity policy used to describe "what to do when a request cannot be satisfied" + * + * Used for both Affinity and Anti-Affinity Groups + */ +export type AffinityPolicy = + /** If the affinity request cannot be satisfied, allow it anyway. + +This enables a "best-effort" attempt to satisfy the affinity policy. */ + | 'allow' + + /** If the affinity request cannot be satisfied, fail explicitly. */ + | 'fail' + +/** + * Identity-related metadata that's included in nearly all public API objects + */ +export type AffinityGroup = { + /** human-readable free-form text about a resource */ + description: string + failureDomain: FailureDomain + /** unique, immutable, system-controlled identifier for each resource */ + id: string + /** unique, mutable, user-controlled identifier for each resource */ + name: Name + policy: AffinityPolicy + /** timestamp when this resource was created */ + timeCreated: Date + /** timestamp when this resource was last modified */ + timeModified: Date +} + +/** + * Create-time parameters for an `AffinityGroup` + */ +export type AffinityGroupCreate = { + description: string + failureDomain: FailureDomain + name: Name + policy: AffinityPolicy +} + +export type TypedUuidForInstanceKind = string + +/** + * A member of an Affinity Group + * + * Membership in a group is not exclusive - members may belong to multiple affinity / anti-affinity groups. + */ +export type AffinityGroupMember = { type: 'instance'; value: TypedUuidForInstanceKind } + +/** + * A single page of results + */ +export type AffinityGroupMemberResultsPage = { + /** list of items on this page of results */ + items: AffinityGroupMember[] + /** token used to fetch the next page of results (if any) */ + nextPage?: string +} + +/** + * A single page of results + */ +export type AffinityGroupResultsPage = { + /** list of items on this page of results */ + items: AffinityGroup[] + /** token used to fetch the next page of results (if any) */ + nextPage?: string +} + +/** + * Updateable properties of an `AffinityGroup` + */ +export type AffinityGroupUpdate = { description?: string; name?: Name } + export type BgpMessageHistory = Record /** @@ -210,6 +291,66 @@ export type AllowListUpdate = { allowedIps: AllowedSourceIps } +/** + * Identity-related metadata that's included in nearly all public API objects + */ +export type AntiAffinityGroup = { + /** human-readable free-form text about a resource */ + description: string + failureDomain: FailureDomain + /** unique, immutable, system-controlled identifier for each resource */ + id: string + /** unique, mutable, user-controlled identifier for each resource */ + name: Name + policy: AffinityPolicy + /** timestamp when this resource was created */ + timeCreated: Date + /** timestamp when this resource was last modified */ + timeModified: Date +} + +/** + * Create-time parameters for an `AntiAffinityGroup` + */ +export type AntiAffinityGroupCreate = { + description: string + failureDomain: FailureDomain + name: Name + policy: AffinityPolicy +} + +/** + * A member of an Anti-Affinity Group + * + * Membership in a group is not exclusive - members may belong to multiple affinity / anti-affinity groups. + */ +export type AntiAffinityGroupMember = { type: 'instance'; value: TypedUuidForInstanceKind } + +/** + * A single page of results + */ +export type AntiAffinityGroupMemberResultsPage = { + /** list of items on this page of results */ + items: AntiAffinityGroupMember[] + /** token used to fetch the next page of results (if any) */ + nextPage?: string +} + +/** + * A single page of results + */ +export type AntiAffinityGroupResultsPage = { + /** list of items on this page of results */ + items: AntiAffinityGroup[] + /** token used to fetch the next page of results (if any) */ + nextPage?: string +} + +/** + * Updateable properties of an `AntiAffinityGroup` + */ +export type AntiAffinityGroupUpdate = { description?: string; name?: Name } + /** * Authorization scope for a timeseries. * @@ -4291,6 +4432,152 @@ export interface LoginSamlPathParams { siloName: Name } +export interface AffinityGroupListQueryParams { + limit?: number + pageToken?: string + project?: NameOrId + sortBy?: NameOrIdSortMode +} + +export interface AffinityGroupCreateQueryParams { + project: NameOrId +} + +export interface AffinityGroupViewPathParams { + affinityGroup: NameOrId +} + +export interface AffinityGroupViewQueryParams { + project?: NameOrId +} + +export interface AffinityGroupUpdatePathParams { + affinityGroup: NameOrId +} + +export interface AffinityGroupUpdateQueryParams { + project?: NameOrId +} + +export interface AffinityGroupDeletePathParams { + affinityGroup: NameOrId +} + +export interface AffinityGroupDeleteQueryParams { + project?: NameOrId +} + +export interface AffinityGroupMemberListPathParams { + affinityGroup: NameOrId +} + +export interface AffinityGroupMemberListQueryParams { + limit?: number + pageToken?: string + project?: NameOrId + sortBy?: IdSortMode +} + +export interface AffinityGroupMemberInstanceViewPathParams { + affinityGroup: NameOrId + instance: NameOrId +} + +export interface AffinityGroupMemberInstanceViewQueryParams { + project?: NameOrId +} + +export interface AffinityGroupMemberInstanceAddPathParams { + affinityGroup: NameOrId + instance: NameOrId +} + +export interface AffinityGroupMemberInstanceAddQueryParams { + project?: NameOrId +} + +export interface AffinityGroupMemberInstanceDeletePathParams { + affinityGroup: NameOrId + instance: NameOrId +} + +export interface AffinityGroupMemberInstanceDeleteQueryParams { + project?: NameOrId +} + +export interface AntiAffinityGroupListQueryParams { + limit?: number + pageToken?: string + project?: NameOrId + sortBy?: NameOrIdSortMode +} + +export interface AntiAffinityGroupCreateQueryParams { + project: NameOrId +} + +export interface AntiAffinityGroupViewPathParams { + antiAffinityGroup: NameOrId +} + +export interface AntiAffinityGroupViewQueryParams { + project?: NameOrId +} + +export interface AntiAffinityGroupUpdatePathParams { + antiAffinityGroup: NameOrId +} + +export interface AntiAffinityGroupUpdateQueryParams { + project?: NameOrId +} + +export interface AntiAffinityGroupDeletePathParams { + antiAffinityGroup: NameOrId +} + +export interface AntiAffinityGroupDeleteQueryParams { + project?: NameOrId +} + +export interface AntiAffinityGroupMemberListPathParams { + antiAffinityGroup: NameOrId +} + +export interface AntiAffinityGroupMemberListQueryParams { + limit?: number + pageToken?: string + project?: NameOrId + sortBy?: IdSortMode +} + +export interface AntiAffinityGroupMemberInstanceViewPathParams { + antiAffinityGroup: NameOrId + instance: NameOrId +} + +export interface AntiAffinityGroupMemberInstanceViewQueryParams { + project?: NameOrId +} + +export interface AntiAffinityGroupMemberInstanceAddPathParams { + antiAffinityGroup: NameOrId + instance: NameOrId +} + +export interface AntiAffinityGroupMemberInstanceAddQueryParams { + project?: NameOrId +} + +export interface AntiAffinityGroupMemberInstanceDeletePathParams { + antiAffinityGroup: NameOrId + instance: NameOrId +} + +export interface AntiAffinityGroupMemberInstanceDeleteQueryParams { + project?: NameOrId +} + export interface CertificateListQueryParams { limit?: number pageToken?: string @@ -5472,6 +5759,10 @@ export type ApiListMethods = Pick< InstanceType['methods'], | 'probeList' | 'supportBundleList' + | 'affinityGroupList' + | 'affinityGroupMemberList' + | 'antiAffinityGroupList' + | 'antiAffinityGroupMemberList' | 'certificateList' | 'diskList' | 'diskMetricsList' @@ -5740,6 +6031,347 @@ export class Api extends HttpClient { ...params, }) }, + /** + * List affinity groups + */ + affinityGroupList: ( + { query = {} }: { query?: AffinityGroupListQueryParams }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/affinity-groups`, + method: 'GET', + query, + ...params, + }) + }, + /** + * Create affinity group + */ + affinityGroupCreate: ( + { query, body }: { query: AffinityGroupCreateQueryParams; body: AffinityGroupCreate }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/affinity-groups`, + method: 'POST', + body, + query, + ...params, + }) + }, + /** + * Fetch affinity group + */ + affinityGroupView: ( + { + path, + query = {}, + }: { path: AffinityGroupViewPathParams; query?: AffinityGroupViewQueryParams }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/affinity-groups/${path.affinityGroup}`, + method: 'GET', + query, + ...params, + }) + }, + /** + * Update affinity group + */ + affinityGroupUpdate: ( + { + path, + query = {}, + body, + }: { + path: AffinityGroupUpdatePathParams + query?: AffinityGroupUpdateQueryParams + body: AffinityGroupUpdate + }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/affinity-groups/${path.affinityGroup}`, + method: 'PUT', + body, + query, + ...params, + }) + }, + /** + * Delete affinity group + */ + affinityGroupDelete: ( + { + path, + query = {}, + }: { path: AffinityGroupDeletePathParams; query?: AffinityGroupDeleteQueryParams }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/affinity-groups/${path.affinityGroup}`, + method: 'DELETE', + query, + ...params, + }) + }, + /** + * List affinity group members + */ + affinityGroupMemberList: ( + { + path, + query = {}, + }: { + path: AffinityGroupMemberListPathParams + query?: AffinityGroupMemberListQueryParams + }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/affinity-groups/${path.affinityGroup}/members`, + method: 'GET', + query, + ...params, + }) + }, + /** + * Fetch affinity group member + */ + affinityGroupMemberInstanceView: ( + { + path, + query = {}, + }: { + path: AffinityGroupMemberInstanceViewPathParams + query?: AffinityGroupMemberInstanceViewQueryParams + }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/affinity-groups/${path.affinityGroup}/members/instance/${path.instance}`, + method: 'GET', + query, + ...params, + }) + }, + /** + * Add member to affinity group + */ + affinityGroupMemberInstanceAdd: ( + { + path, + query = {}, + }: { + path: AffinityGroupMemberInstanceAddPathParams + query?: AffinityGroupMemberInstanceAddQueryParams + }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/affinity-groups/${path.affinityGroup}/members/instance/${path.instance}`, + method: 'POST', + query, + ...params, + }) + }, + /** + * Remove member from affinity group + */ + affinityGroupMemberInstanceDelete: ( + { + path, + query = {}, + }: { + path: AffinityGroupMemberInstanceDeletePathParams + query?: AffinityGroupMemberInstanceDeleteQueryParams + }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/affinity-groups/${path.affinityGroup}/members/instance/${path.instance}`, + method: 'DELETE', + query, + ...params, + }) + }, + /** + * List anti-affinity groups + */ + antiAffinityGroupList: ( + { query = {} }: { query?: AntiAffinityGroupListQueryParams }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/anti-affinity-groups`, + method: 'GET', + query, + ...params, + }) + }, + /** + * Create anti-affinity group + */ + antiAffinityGroupCreate: ( + { + query, + body, + }: { query: AntiAffinityGroupCreateQueryParams; body: AntiAffinityGroupCreate }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/anti-affinity-groups`, + method: 'POST', + body, + query, + ...params, + }) + }, + /** + * Fetch anti-affinity group + */ + antiAffinityGroupView: ( + { + path, + query = {}, + }: { + path: AntiAffinityGroupViewPathParams + query?: AntiAffinityGroupViewQueryParams + }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/anti-affinity-groups/${path.antiAffinityGroup}`, + method: 'GET', + query, + ...params, + }) + }, + /** + * Update anti-affinity group + */ + antiAffinityGroupUpdate: ( + { + path, + query = {}, + body, + }: { + path: AntiAffinityGroupUpdatePathParams + query?: AntiAffinityGroupUpdateQueryParams + body: AntiAffinityGroupUpdate + }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/anti-affinity-groups/${path.antiAffinityGroup}`, + method: 'PUT', + body, + query, + ...params, + }) + }, + /** + * Delete anti-affinity group + */ + antiAffinityGroupDelete: ( + { + path, + query = {}, + }: { + path: AntiAffinityGroupDeletePathParams + query?: AntiAffinityGroupDeleteQueryParams + }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/anti-affinity-groups/${path.antiAffinityGroup}`, + method: 'DELETE', + query, + ...params, + }) + }, + /** + * List anti-affinity group members + */ + antiAffinityGroupMemberList: ( + { + path, + query = {}, + }: { + path: AntiAffinityGroupMemberListPathParams + query?: AntiAffinityGroupMemberListQueryParams + }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/anti-affinity-groups/${path.antiAffinityGroup}/members`, + method: 'GET', + query, + ...params, + }) + }, + /** + * Fetch anti-affinity group member + */ + antiAffinityGroupMemberInstanceView: ( + { + path, + query = {}, + }: { + path: AntiAffinityGroupMemberInstanceViewPathParams + query?: AntiAffinityGroupMemberInstanceViewQueryParams + }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/anti-affinity-groups/${path.antiAffinityGroup}/members/instance/${path.instance}`, + method: 'GET', + query, + ...params, + }) + }, + /** + * Add member to anti-affinity group + */ + antiAffinityGroupMemberInstanceAdd: ( + { + path, + query = {}, + }: { + path: AntiAffinityGroupMemberInstanceAddPathParams + query?: AntiAffinityGroupMemberInstanceAddQueryParams + }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/anti-affinity-groups/${path.antiAffinityGroup}/members/instance/${path.instance}`, + method: 'POST', + query, + ...params, + }) + }, + /** + * Remove member from anti-affinity group + */ + antiAffinityGroupMemberInstanceDelete: ( + { + path, + query = {}, + }: { + path: AntiAffinityGroupMemberInstanceDeletePathParams + query?: AntiAffinityGroupMemberInstanceDeleteQueryParams + }, + params: FetchParams = {} + ) => { + return this.request({ + path: `/v1/anti-affinity-groups/${path.antiAffinityGroup}/members/instance/${path.instance}`, + method: 'DELETE', + query, + ...params, + }) + }, /** * List certificates for external endpoints */ diff --git a/app/api/__generated__/OMICRON_VERSION b/app/api/__generated__/OMICRON_VERSION index 4d019212a..57a5929da 100644 --- a/app/api/__generated__/OMICRON_VERSION +++ b/app/api/__generated__/OMICRON_VERSION @@ -1,2 +1,2 @@ # generated file. do not update manually. see docs/update-pinned-api.md -eeeb429a5a4c3aeff484c50638255f4c4eadc9ba +5342337ca3703fb5011deccc9abc270693d9bdd1 diff --git a/app/api/__generated__/msw-handlers.ts b/app/api/__generated__/msw-handlers.ts index 1ffb97a24..ce3607b4b 100644 --- a/app/api/__generated__/msw-handlers.ts +++ b/app/api/__generated__/msw-handlers.ts @@ -147,6 +147,132 @@ export interface MSWHandlers { req: Request cookies: Record }) => Promisable + /** `GET /v1/affinity-groups` */ + affinityGroupList: (params: { + query: Api.AffinityGroupListQueryParams + req: Request + cookies: Record + }) => Promisable> + /** `POST /v1/affinity-groups` */ + affinityGroupCreate: (params: { + query: Api.AffinityGroupCreateQueryParams + body: Json + req: Request + cookies: Record + }) => Promisable> + /** `GET /v1/affinity-groups/:affinityGroup` */ + affinityGroupView: (params: { + path: Api.AffinityGroupViewPathParams + query: Api.AffinityGroupViewQueryParams + req: Request + cookies: Record + }) => Promisable> + /** `PUT /v1/affinity-groups/:affinityGroup` */ + affinityGroupUpdate: (params: { + path: Api.AffinityGroupUpdatePathParams + query: Api.AffinityGroupUpdateQueryParams + body: Json + req: Request + cookies: Record + }) => Promisable> + /** `DELETE /v1/affinity-groups/:affinityGroup` */ + affinityGroupDelete: (params: { + path: Api.AffinityGroupDeletePathParams + query: Api.AffinityGroupDeleteQueryParams + req: Request + cookies: Record + }) => Promisable + /** `GET /v1/affinity-groups/:affinityGroup/members` */ + affinityGroupMemberList: (params: { + path: Api.AffinityGroupMemberListPathParams + query: Api.AffinityGroupMemberListQueryParams + req: Request + cookies: Record + }) => Promisable> + /** `GET /v1/affinity-groups/:affinityGroup/members/instance/:instance` */ + affinityGroupMemberInstanceView: (params: { + path: Api.AffinityGroupMemberInstanceViewPathParams + query: Api.AffinityGroupMemberInstanceViewQueryParams + req: Request + cookies: Record + }) => Promisable> + /** `POST /v1/affinity-groups/:affinityGroup/members/instance/:instance` */ + affinityGroupMemberInstanceAdd: (params: { + path: Api.AffinityGroupMemberInstanceAddPathParams + query: Api.AffinityGroupMemberInstanceAddQueryParams + req: Request + cookies: Record + }) => Promisable> + /** `DELETE /v1/affinity-groups/:affinityGroup/members/instance/:instance` */ + affinityGroupMemberInstanceDelete: (params: { + path: Api.AffinityGroupMemberInstanceDeletePathParams + query: Api.AffinityGroupMemberInstanceDeleteQueryParams + req: Request + cookies: Record + }) => Promisable + /** `GET /v1/anti-affinity-groups` */ + antiAffinityGroupList: (params: { + query: Api.AntiAffinityGroupListQueryParams + req: Request + cookies: Record + }) => Promisable> + /** `POST /v1/anti-affinity-groups` */ + antiAffinityGroupCreate: (params: { + query: Api.AntiAffinityGroupCreateQueryParams + body: Json + req: Request + cookies: Record + }) => Promisable> + /** `GET /v1/anti-affinity-groups/:antiAffinityGroup` */ + antiAffinityGroupView: (params: { + path: Api.AntiAffinityGroupViewPathParams + query: Api.AntiAffinityGroupViewQueryParams + req: Request + cookies: Record + }) => Promisable> + /** `PUT /v1/anti-affinity-groups/:antiAffinityGroup` */ + antiAffinityGroupUpdate: (params: { + path: Api.AntiAffinityGroupUpdatePathParams + query: Api.AntiAffinityGroupUpdateQueryParams + body: Json + req: Request + cookies: Record + }) => Promisable> + /** `DELETE /v1/anti-affinity-groups/:antiAffinityGroup` */ + antiAffinityGroupDelete: (params: { + path: Api.AntiAffinityGroupDeletePathParams + query: Api.AntiAffinityGroupDeleteQueryParams + req: Request + cookies: Record + }) => Promisable + /** `GET /v1/anti-affinity-groups/:antiAffinityGroup/members` */ + antiAffinityGroupMemberList: (params: { + path: Api.AntiAffinityGroupMemberListPathParams + query: Api.AntiAffinityGroupMemberListQueryParams + req: Request + cookies: Record + }) => Promisable> + /** `GET /v1/anti-affinity-groups/:antiAffinityGroup/members/instance/:instance` */ + antiAffinityGroupMemberInstanceView: (params: { + path: Api.AntiAffinityGroupMemberInstanceViewPathParams + query: Api.AntiAffinityGroupMemberInstanceViewQueryParams + req: Request + cookies: Record + }) => Promisable> + /** `POST /v1/anti-affinity-groups/:antiAffinityGroup/members/instance/:instance` */ + antiAffinityGroupMemberInstanceAdd: (params: { + path: Api.AntiAffinityGroupMemberInstanceAddPathParams + query: Api.AntiAffinityGroupMemberInstanceAddQueryParams + req: Request + cookies: Record + }) => Promisable> + /** `DELETE /v1/anti-affinity-groups/:antiAffinityGroup/members/instance/:instance` */ + antiAffinityGroupMemberInstanceDelete: (params: { + path: Api.AntiAffinityGroupMemberInstanceDeletePathParams + query: Api.AntiAffinityGroupMemberInstanceDeleteQueryParams + req: Request + cookies: Record + }) => Promisable /** `GET /v1/certificates` */ certificateList: (params: { query: Api.CertificateListQueryParams @@ -1646,6 +1772,130 @@ export function makeHandlers(handlers: MSWHandlers): HttpHandler[] { '/login/:siloName/saml/:providerName', handler(handlers['loginSaml'], schema.LoginSamlParams, null) ), + http.get( + '/v1/affinity-groups', + handler(handlers['affinityGroupList'], schema.AffinityGroupListParams, null) + ), + http.post( + '/v1/affinity-groups', + handler( + handlers['affinityGroupCreate'], + schema.AffinityGroupCreateParams, + schema.AffinityGroupCreate + ) + ), + http.get( + '/v1/affinity-groups/:affinityGroup', + handler(handlers['affinityGroupView'], schema.AffinityGroupViewParams, null) + ), + http.put( + '/v1/affinity-groups/:affinityGroup', + handler( + handlers['affinityGroupUpdate'], + schema.AffinityGroupUpdateParams, + schema.AffinityGroupUpdate + ) + ), + http.delete( + '/v1/affinity-groups/:affinityGroup', + handler(handlers['affinityGroupDelete'], schema.AffinityGroupDeleteParams, null) + ), + http.get( + '/v1/affinity-groups/:affinityGroup/members', + handler( + handlers['affinityGroupMemberList'], + schema.AffinityGroupMemberListParams, + null + ) + ), + http.get( + '/v1/affinity-groups/:affinityGroup/members/instance/:instance', + handler( + handlers['affinityGroupMemberInstanceView'], + schema.AffinityGroupMemberInstanceViewParams, + null + ) + ), + http.post( + '/v1/affinity-groups/:affinityGroup/members/instance/:instance', + handler( + handlers['affinityGroupMemberInstanceAdd'], + schema.AffinityGroupMemberInstanceAddParams, + null + ) + ), + http.delete( + '/v1/affinity-groups/:affinityGroup/members/instance/:instance', + handler( + handlers['affinityGroupMemberInstanceDelete'], + schema.AffinityGroupMemberInstanceDeleteParams, + null + ) + ), + http.get( + '/v1/anti-affinity-groups', + handler(handlers['antiAffinityGroupList'], schema.AntiAffinityGroupListParams, null) + ), + http.post( + '/v1/anti-affinity-groups', + handler( + handlers['antiAffinityGroupCreate'], + schema.AntiAffinityGroupCreateParams, + schema.AntiAffinityGroupCreate + ) + ), + http.get( + '/v1/anti-affinity-groups/:antiAffinityGroup', + handler(handlers['antiAffinityGroupView'], schema.AntiAffinityGroupViewParams, null) + ), + http.put( + '/v1/anti-affinity-groups/:antiAffinityGroup', + handler( + handlers['antiAffinityGroupUpdate'], + schema.AntiAffinityGroupUpdateParams, + schema.AntiAffinityGroupUpdate + ) + ), + http.delete( + '/v1/anti-affinity-groups/:antiAffinityGroup', + handler( + handlers['antiAffinityGroupDelete'], + schema.AntiAffinityGroupDeleteParams, + null + ) + ), + http.get( + '/v1/anti-affinity-groups/:antiAffinityGroup/members', + handler( + handlers['antiAffinityGroupMemberList'], + schema.AntiAffinityGroupMemberListParams, + null + ) + ), + http.get( + '/v1/anti-affinity-groups/:antiAffinityGroup/members/instance/:instance', + handler( + handlers['antiAffinityGroupMemberInstanceView'], + schema.AntiAffinityGroupMemberInstanceViewParams, + null + ) + ), + http.post( + '/v1/anti-affinity-groups/:antiAffinityGroup/members/instance/:instance', + handler( + handlers['antiAffinityGroupMemberInstanceAdd'], + schema.AntiAffinityGroupMemberInstanceAddParams, + null + ) + ), + http.delete( + '/v1/anti-affinity-groups/:antiAffinityGroup/members/instance/:instance', + handler( + handlers['antiAffinityGroupMemberInstanceDelete'], + schema.AntiAffinityGroupMemberInstanceDeleteParams, + null + ) + ), http.get( '/v1/certificates', handler(handlers['certificateList'], schema.CertificateListParams, null) diff --git a/app/api/__generated__/validate.ts b/app/api/__generated__/validate.ts index f554d5b36..1e66ed8af 100644 --- a/app/api/__generated__/validate.ts +++ b/app/api/__generated__/validate.ts @@ -173,6 +173,83 @@ export const AddressLotResultsPage = z.preprocess( z.object({ items: AddressLot.array(), nextPage: z.string().optional() }) ) +/** + * Describes the scope of affinity for the purposes of co-location. + */ +export const FailureDomain = z.preprocess(processResponseBody, z.enum(['sled'])) + +/** + * Affinity policy used to describe "what to do when a request cannot be satisfied" + * + * Used for both Affinity and Anti-Affinity Groups + */ +export const AffinityPolicy = z.preprocess(processResponseBody, z.enum(['allow', 'fail'])) + +/** + * Identity-related metadata that's included in nearly all public API objects + */ +export const AffinityGroup = z.preprocess( + processResponseBody, + z.object({ + description: z.string(), + failureDomain: FailureDomain, + id: z.string().uuid(), + name: Name, + policy: AffinityPolicy, + timeCreated: z.coerce.date(), + timeModified: z.coerce.date(), + }) +) + +/** + * Create-time parameters for an `AffinityGroup` + */ +export const AffinityGroupCreate = z.preprocess( + processResponseBody, + z.object({ + description: z.string(), + failureDomain: FailureDomain, + name: Name, + policy: AffinityPolicy, + }) +) + +export const TypedUuidForInstanceKind = z.preprocess(processResponseBody, z.string().uuid()) + +/** + * A member of an Affinity Group + * + * Membership in a group is not exclusive - members may belong to multiple affinity / anti-affinity groups. + */ +export const AffinityGroupMember = z.preprocess( + processResponseBody, + z.object({ type: z.enum(['instance']), value: TypedUuidForInstanceKind }) +) + +/** + * A single page of results + */ +export const AffinityGroupMemberResultsPage = z.preprocess( + processResponseBody, + z.object({ items: AffinityGroupMember.array(), nextPage: z.string().optional() }) +) + +/** + * A single page of results + */ +export const AffinityGroupResultsPage = z.preprocess( + processResponseBody, + z.object({ items: AffinityGroup.array(), nextPage: z.string().optional() }) +) + +/** + * Updateable properties of an `AffinityGroup` + */ +export const AffinityGroupUpdate = z.preprocess( + processResponseBody, + z.object({ description: z.string().optional(), name: Name.optional() }) +) + export const BgpMessageHistory = z.preprocess(processResponseBody, z.record(z.unknown())) /** @@ -233,6 +310,69 @@ export const AllowListUpdate = z.preprocess( z.object({ allowedIps: AllowedSourceIps }) ) +/** + * Identity-related metadata that's included in nearly all public API objects + */ +export const AntiAffinityGroup = z.preprocess( + processResponseBody, + z.object({ + description: z.string(), + failureDomain: FailureDomain, + id: z.string().uuid(), + name: Name, + policy: AffinityPolicy, + timeCreated: z.coerce.date(), + timeModified: z.coerce.date(), + }) +) + +/** + * Create-time parameters for an `AntiAffinityGroup` + */ +export const AntiAffinityGroupCreate = z.preprocess( + processResponseBody, + z.object({ + description: z.string(), + failureDomain: FailureDomain, + name: Name, + policy: AffinityPolicy, + }) +) + +/** + * A member of an Anti-Affinity Group + * + * Membership in a group is not exclusive - members may belong to multiple affinity / anti-affinity groups. + */ +export const AntiAffinityGroupMember = z.preprocess( + processResponseBody, + z.object({ type: z.enum(['instance']), value: TypedUuidForInstanceKind }) +) + +/** + * A single page of results + */ +export const AntiAffinityGroupMemberResultsPage = z.preprocess( + processResponseBody, + z.object({ items: AntiAffinityGroupMember.array(), nextPage: z.string().optional() }) +) + +/** + * A single page of results + */ +export const AntiAffinityGroupResultsPage = z.preprocess( + processResponseBody, + z.object({ items: AntiAffinityGroup.array(), nextPage: z.string().optional() }) +) + +/** + * Updateable properties of an `AntiAffinityGroup` + */ +export const AntiAffinityGroupUpdate = z.preprocess( + processResponseBody, + z.object({ description: z.string().optional(), name: Name.optional() }) +) + /** * Authorization scope for a timeseries. * @@ -4071,6 +4211,232 @@ export const LoginSamlParams = z.preprocess( }) ) +export const AffinityGroupListParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({}), + query: z.object({ + limit: z.number().min(1).max(4294967295).optional(), + pageToken: z.string().optional(), + project: NameOrId.optional(), + sortBy: NameOrIdSortMode.optional(), + }), + }) +) + +export const AffinityGroupCreateParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({}), + query: z.object({ + project: NameOrId, + }), + }) +) + +export const AffinityGroupViewParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({ + affinityGroup: NameOrId, + }), + query: z.object({ + project: NameOrId.optional(), + }), + }) +) + +export const AffinityGroupUpdateParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({ + affinityGroup: NameOrId, + }), + query: z.object({ + project: NameOrId.optional(), + }), + }) +) + +export const AffinityGroupDeleteParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({ + affinityGroup: NameOrId, + }), + query: z.object({ + project: NameOrId.optional(), + }), + }) +) + +export const AffinityGroupMemberListParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({ + affinityGroup: NameOrId, + }), + query: z.object({ + limit: z.number().min(1).max(4294967295).optional(), + pageToken: z.string().optional(), + project: NameOrId.optional(), + sortBy: IdSortMode.optional(), + }), + }) +) + +export const AffinityGroupMemberInstanceViewParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({ + affinityGroup: NameOrId, + instance: NameOrId, + }), + query: z.object({ + project: NameOrId.optional(), + }), + }) +) + +export const AffinityGroupMemberInstanceAddParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({ + affinityGroup: NameOrId, + instance: NameOrId, + }), + query: z.object({ + project: NameOrId.optional(), + }), + }) +) + +export const AffinityGroupMemberInstanceDeleteParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({ + affinityGroup: NameOrId, + instance: NameOrId, + }), + query: z.object({ + project: NameOrId.optional(), + }), + }) +) + +export const AntiAffinityGroupListParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({}), + query: z.object({ + limit: z.number().min(1).max(4294967295).optional(), + pageToken: z.string().optional(), + project: NameOrId.optional(), + sortBy: NameOrIdSortMode.optional(), + }), + }) +) + +export const AntiAffinityGroupCreateParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({}), + query: z.object({ + project: NameOrId, + }), + }) +) + +export const AntiAffinityGroupViewParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({ + antiAffinityGroup: NameOrId, + }), + query: z.object({ + project: NameOrId.optional(), + }), + }) +) + +export const AntiAffinityGroupUpdateParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({ + antiAffinityGroup: NameOrId, + }), + query: z.object({ + project: NameOrId.optional(), + }), + }) +) + +export const AntiAffinityGroupDeleteParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({ + antiAffinityGroup: NameOrId, + }), + query: z.object({ + project: NameOrId.optional(), + }), + }) +) + +export const AntiAffinityGroupMemberListParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({ + antiAffinityGroup: NameOrId, + }), + query: z.object({ + limit: z.number().min(1).max(4294967295).optional(), + pageToken: z.string().optional(), + project: NameOrId.optional(), + sortBy: IdSortMode.optional(), + }), + }) +) + +export const AntiAffinityGroupMemberInstanceViewParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({ + antiAffinityGroup: NameOrId, + instance: NameOrId, + }), + query: z.object({ + project: NameOrId.optional(), + }), + }) +) + +export const AntiAffinityGroupMemberInstanceAddParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({ + antiAffinityGroup: NameOrId, + instance: NameOrId, + }), + query: z.object({ + project: NameOrId.optional(), + }), + }) +) + +export const AntiAffinityGroupMemberInstanceDeleteParams = z.preprocess( + processResponseBody, + z.object({ + path: z.object({ + antiAffinityGroup: NameOrId, + instance: NameOrId, + }), + query: z.object({ + project: NameOrId.optional(), + }), + }) +) + export const CertificateListParams = z.preprocess( processResponseBody, z.object({ diff --git a/mock-api/msw/handlers.ts b/mock-api/msw/handlers.ts index 129932775..4a7674eb0 100644 --- a/mock-api/msw/handlers.ts +++ b/mock-api/msw/handlers.ts @@ -1608,6 +1608,24 @@ export const handlers = makeHandlers({ siloMetric: handleMetrics, // Misc endpoints we're not using yet in the console + affinityGroupCreate: NotImplemented, + affinityGroupDelete: NotImplemented, + affinityGroupList: NotImplemented, + affinityGroupMemberInstanceAdd: NotImplemented, + affinityGroupMemberInstanceDelete: NotImplemented, + affinityGroupMemberInstanceView: NotImplemented, + affinityGroupMemberList: NotImplemented, + affinityGroupUpdate: NotImplemented, + affinityGroupView: NotImplemented, + antiAffinityGroupCreate: NotImplemented, + antiAffinityGroupDelete: NotImplemented, + antiAffinityGroupList: NotImplemented, + antiAffinityGroupMemberInstanceAdd: NotImplemented, + antiAffinityGroupMemberInstanceDelete: NotImplemented, + antiAffinityGroupMemberInstanceView: NotImplemented, + antiAffinityGroupMemberList: NotImplemented, + antiAffinityGroupUpdate: NotImplemented, + antiAffinityGroupView: NotImplemented, certificateCreate: NotImplemented, certificateDelete: NotImplemented, certificateList: NotImplemented,