@serve.zone/interfaces 32.12.0 → 32.14.0

package/ts/data/index.ts

@@ -17,6 +17,7 @@ export * from './docker.js';
 export * from './domain.js';
 export * from './event.js';
 export * from './externalregistry.js';
+export * from './fleetcutover.js';
 export * from './gateway.js';
 export * from './hostedapp.js';
 export * from './image.js';

package/ts/requests/fleetcutover.ts

@@ -0,0 +1,160 @@
+import * as plugins from '../plugins.js';
+import type { IIdentityCredential } from '../data/user.js';
+import type { IClusterRuntime } from '../data/clusterruntime.js';
+import type { IServiceRuntimeSpec } from '../data/serviceruntime.js';
+import type {
+  IFleetCutoverAcceptedEvidenceReference,
+  IFleetCutoverCorestoreAdoptionReceipt,
+  IFleetCutoverIngressDesignation,
+  IFleetCutoverIngressPreparationRequest,
+  IFleetCutoverIngressAuthority,
+  IFleetCutoverScope,
+  IFleetCutoverScopeClassificationRequest,
+  IFleetCutoverVolumeHandoffIntent,
+  TFleetCutoverPhaseAdvance,
+  TFleetCutoverRuntimeSpecRelease,
+  TFleetCutoverVolumeFence,
+} from '../data/fleetcutover.js';
+
+export interface IReq_Any_Cloudly_GetFleetCutoverScope
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Any_Cloudly_GetFleetCutoverScope
+> {
+  method: 'getFleetCutoverScope';
+  request: { identity: IIdentityCredential; clusterId: string };
+  response: { scope: IFleetCutoverScope | null };
+}
+
+/**
+ * The administrator classifies the exact current census candidate. Cloudly compares every entry
+ * with its current service, platform-service, credential, and storage authority before it may
+ * persist a complete scope; the request itself is no proof of those facts.
+ */
+export interface IReq_Admin_Cloudly_ClassifyFleetCutoverScope
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Admin_Cloudly_ClassifyFleetCutoverScope
+> {
+  method: 'classifyFleetCutoverScope';
+  request: {
+    identity: IIdentityCredential;
+    classification: IFleetCutoverScopeClassificationRequest;
+  };
+  response: { scope: IFleetCutoverScope };
+}
+
+/**
+ * Forward-only legal phase CAS. All receipt references are dereferenced by Cloudly in the same
+ * transaction; caller-supplied records or booleans never satisfy a cutover condition.
+ */
+export interface IReq_Admin_Cloudly_AdvanceFleetCutoverPhase
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Admin_Cloudly_AdvanceFleetCutoverPhase
+> {
+  method: 'advanceFleetCutoverPhase';
+  request: { identity: IIdentityCredential; advance: TFleetCutoverPhaseAdvance };
+  response: { runtime: IClusterRuntime; replayed: boolean };
+}
+
+/**
+ * Cloudly designates one existing live service as the new ingress before assignment. It accepts
+ * only current owner state and creates the managed launcher bearer and designation atomically.
+ */
+export interface IReq_Admin_Cloudly_PrepareFleetCutoverIngress
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Admin_Cloudly_PrepareFleetCutoverIngress
+> {
+  method: 'prepareFleetCutoverIngress';
+  request: {
+    identity: IIdentityCredential;
+    preparation: IFleetCutoverIngressPreparationRequest;
+  };
+  response: {
+    designation: IFleetCutoverIngressDesignation;
+    /** The resulting exact-cluster spec, still held after preparation. */
+    spec: IServiceRuntimeSpec;
+    replayed: boolean;
+  };
+}
+
+/**
+ * The only cutover-specific hold release. Ingress releases first under an accepted empty public
+ * port policy; applications require the accepted ingress/port/route authority assembled later.
+ */
+export interface IReq_Admin_Cloudly_ReleaseFleetCutoverRuntimeSpec
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Admin_Cloudly_ReleaseFleetCutoverRuntimeSpec
+> {
+  method: 'releaseFleetCutoverRuntimeSpec';
+  request: { identity: IIdentityCredential; release: TFleetCutoverRuntimeSpecRelease };
+  response: { spec: IServiceRuntimeSpec; replayed: boolean };
+}
+
+export interface IReq_Any_Cloudly_GetFleetCutoverIngressAuthority
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Any_Cloudly_GetFleetCutoverIngressAuthority
+> {
+  method: 'getFleetCutoverIngressAuthority';
+  request: { identity: IIdentityCredential; clusterId: string };
+  response: { authority: IFleetCutoverIngressAuthority | null };
+}
+
+/** Root-local only. Holding an intent creates negative storage authority and no runtime session. */
+export interface IReq_PalletLocal_Pallet_HoldFleetCutoverVolumeFence
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_PalletLocal_Pallet_HoldFleetCutoverVolumeFence
+> {
+  method: 'holdFleetCutoverVolumeFence';
+  request: { fenceId: string; handoffIntent: IFleetCutoverVolumeHandoffIntent };
+  response: { fence: Extract<TFleetCutoverVolumeFence, { state: 'held' }> };
+}
+
+export interface IReq_PalletLocal_Pallet_GetFleetCutoverVolumeFence
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_PalletLocal_Pallet_GetFleetCutoverVolumeFence
+> {
+  method: 'getFleetCutoverVolumeFence';
+  request: { fenceId: string };
+  response: { fence: TFleetCutoverVolumeFence | null };
+}
+
+/**
+ * Pallet consumes the local fence only around a current accepted Corestore adoption result. The
+ * receipt carries the real ready storage-claim reference; the earlier handoff intent does not.
+ */
+export interface IReq_PalletLocal_Pallet_ConsumeFleetCutoverVolumeFence
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_PalletLocal_Pallet_ConsumeFleetCutoverVolumeFence
+> {
+  method: 'consumeFleetCutoverVolumeFence';
+  request: {
+    fence: IFleetCutoverAcceptedEvidenceReference;
+    adoption: IFleetCutoverCorestoreAdoptionReceipt;
+  };
+  response: { fence: Extract<TFleetCutoverVolumeFence, { state: 'consumed' }> };
+}
+
+/**
+ * Corestore owns the one-shot initial lineage/RWO CAS. The local caller supplies the held fence
+ * and server-owned handoff intent; Corestore returns the claim only after its provider is ready.
+ */
+export interface IReq_Pallet_Corestore_AdoptFleetCutoverVolume
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Pallet_Corestore_AdoptFleetCutoverVolume
+> {
+  method: 'adoptFleetCutoverVolume';
+  request: {
+    handoffIntent: IFleetCutoverVolumeHandoffIntent;
+    palletFence: Extract<TFleetCutoverVolumeFence, { state: 'held' }>;
+  };
+  response: { adoption: IFleetCutoverCorestoreAdoptionReceipt };
+}

package/ts/requests/index.ts

@@ -16,6 +16,7 @@ import * as deploymentRequests from './deployment.js';
 import * as dnsRequests from './dns.js';
 import * as domainRequests from './domain.js';
 import * as externalRegistryRequests from './externalregistry.js';
+import * as fleetCutoverRequests from './fleetcutover.js';
 import * as gatewayRequests from './gateway.js';
 import * as hostedAppRequests from './hostedapp.js';
 import * as identityRequests from './identity.js';
@@ -55,6 +56,7 @@ export {
   dnsRequests as dns,
   domainRequests as domain,
   externalRegistryRequests as externalRegistry,
+  fleetCutoverRequests as fleetcutover,
   gatewayRequests as gateway,
   hostedAppRequests as hostedapp,
   identityRequests as identity,