@alchemy.run/docker 2.0.0-beta.84 → 2.0.0-beta.85

package/src/Service.ts

@@ -10,6 +10,7 @@ import {
 } from "alchemy/Runtime/Process";
 import { Stack } from "alchemy/Stack";
 import { createInternalTags, hasAlchemyTags } from "alchemy/Tags";
+import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Equal from "effect/Equal";
 import type { PlatformError } from "effect/PlatformError";
@@ -345,9 +346,14 @@ export interface ServiceRuntimeContext extends HostRuntimeContext {
  * image on a registry every node can reach (build with `Docker.Image` +
  * `registry` and pass the pushed ref as `image` instead).
  *
- * Only replicated services are supported. Configuration changes replace the
- * service (delete-then-create); swarm tasks are stateless, so replacement is
- * cheap and avoids partially-applied `service update` drift.
+ * Only replicated services are supported. Changes to the image, replicas,
+ * environment, labels, networks, ports, mounts, secrets, configs, constraints,
+ * healthcheck, and rollout or restart policies are applied in place with
+ * `docker service update`, so swarm rolls tasks over following `updateConfig`.
+ * An update that swarm rolls back or pauses fails the deploy with
+ * `DockerServiceUpdateFailed`. Changing the name, context, command, args,
+ * endpoint mode, placement preferences, or read-only root filesystem, or
+ * removing a policy setting, replaces the service (delete-then-create).
  * ### Creating Services
  * **Example:** Replicated Nginx
  * ```typescript
@@ -519,16 +525,39 @@ export const Service: Platform<Service, ServiceServices, ServiceShape, ServiceRu
 const isBundledService = (props: ServiceProps): props is BundledServiceProps =>
   typeof (props as BundledServiceProps).main === "string";
 
+/**
+ * A `docker service update` that swarm rolled back or paused instead of
+ * completing. `--detach=false` exits 0 on a rollback and 1 on a pause, so the
+ * provider reads the service's `UpdateStatus` after the update.
+ */
+export class DockerServiceUpdateFailed extends Data.TaggedError("DockerServiceUpdateFailed")<{
+  readonly service: string;
+  readonly state: string;
+  readonly reason: string;
+}> {
+  override get message() {
+    return `Update of service "${this.service}" ended in ${this.state}: ${this.reason}`;
+  }
+}
+
 type ServiceInspect = {
   ID: string;
   CreatedAt?: string;
   UpdatedAt?: string;
+  UpdateStatus?: {
+    State?: string;
+    Message?: string;
+  };
   Spec: {
     Name: string;
     Labels?: Record<string, string> | null;
     TaskTemplate?: {
       ContainerSpec?: {
         Image?: string;
+        Env?: string[] | null;
+        Mounts?: Array<{ Target?: string }> | null;
+        Secrets?: Array<{ SecretName?: string }> | null;
+        Configs?: Array<{ ConfigName?: string }> | null;
       };
       Networks?: Array<{ Target?: string }>;
       Placement?: {
@@ -623,18 +652,20 @@ export const ServiceProvider = () =>
           const newDesired = yield* normalizeDesired(id, news, instanceId);
 
           if (!Equal.equals(oldDesired, newDesired)) {
-            return { action: "replace" as const, deleteFirst: true };
+            return requiresReplacement(oldDesired, newDesired)
+              ? { action: "replace" as const, deleteFirst: true }
+              : { action: "update" as const };
           }
 
           // Bundled program: the image identity is the content hash — a code
-          // or bootstrap change replaces the service with the new image.
+          // or bootstrap change rolls the service onto the new image.
           if (isBundledService(news)) {
             const hash = yield* serviceImage.hash({
               source: news,
               isExternal: news.isExternal,
             });
             if (hash !== output?.code?.hash) {
-              return { action: "replace" as const, deleteFirst: true };
+              return { action: "update" as const };
             }
           }
 
@@ -673,61 +704,144 @@ export const ServiceProvider = () =>
               const labelsToRemove = Object.keys(currentLabels).filter(
                 (k) => !(k in allDesiredLabels),
               );
-              yield* docker.service.update({
-                context: desired.context,
-                id: output.id,
-                image,
-                replicas: desired.replicas,
-                "endpoint-mode": desired.endpointMode,
-                "constraint-add": desired.constraints,
-                "replicas-max-per-node": desired.maxReplicasPerNode,
-                "placement-pref": desired.preferences,
-                "update-parallelism": desired.updateConfig?.parallelism,
-                "update-delay": desired.updateConfig?.delay,
-                "update-monitor": desired.updateConfig?.monitor,
-                "update-failure-action": desired.updateConfig?.failureAction,
-                "update-max-failure-ratio": desired.updateConfig?.maxFailureRatio,
-                "update-order": desired.updateConfig?.order,
-                "rollback-parallelism": desired.rollbackConfig?.parallelism,
-                "rollback-delay": desired.rollbackConfig?.delay,
-                "rollback-monitor": desired.rollbackConfig?.monitor,
-                "rollback-failure-action": desired.rollbackConfig?.failureAction,
-                "rollback-max-failure-ratio": desired.rollbackConfig?.maxFailureRatio,
-                "rollback-order": desired.rollbackConfig?.order,
-                "restart-condition": desired.restartPolicy?.condition,
-                "restart-delay": desired.restartPolicy?.delay,
-                "restart-max-attempts": desired.restartPolicy?.maxAttempts,
-                "restart-window": desired.restartPolicy?.window,
-                "health-cmd": desired.healthcheck
-                  ? healthcheckCommand(desired.healthcheck.cmd)
-                  : undefined,
-                "no-healthcheck":
-                  desired.healthcheck !== undefined &&
-                  isHealthcheckDisabled(desired.healthcheck.cmd),
-                "health-interval": desired.healthcheck?.interval,
-                "health-timeout": desired.healthcheck?.timeout,
-                "health-retries": desired.healthcheck?.retries,
-                "health-start-period": desired.healthcheck?.startPeriod,
-                "stop-grace-period": desired.stopGracePeriod,
-                "mount-add": desired.volumes.map(formatMount),
-                "secret-add": desired.secrets.map(formatRef),
-                "config-add": desired.configs.map(formatRef),
-                "read-only": desired.readOnlyRootFs || undefined,
-                "publish-add": desired.ports.map(formatPublish),
-                "label-add": allDesiredLabels,
-                "label-rm": labelsToRemove,
-                "env-add": environment,
-                args:
-                  desired.command.length > 0
-                    ? desired.command.concat(desired.args).join(" ")
+              // `service update` only adds and removes list entries, so the
+              // removals are computed from the observed spec rather than olds.
+              const spec = current.Spec.TaskTemplate?.ContainerSpec;
+              const envToRemove = (spec?.Env ?? [])
+                .map((entry) => entry.split("=", 1)[0]!)
+                .filter((key) => !(key in environment));
+              const currentConstraints = current.Spec.TaskTemplate?.Placement?.Constraints ?? [];
+              const constraintsToRemove = currentConstraints.filter(
+                (c) => !desired.constraints.includes(c),
+              );
+              // `--constraint-add` appends without de-duplicating.
+              const constraintsToAdd = desired.constraints.filter(
+                (c) => !currentConstraints.includes(c),
+              );
+              const desiredTargets = new Set(desired.volumes.map((v) => v.containerPath));
+              const mountsToRemove = (spec?.Mounts ?? []).flatMap((m) =>
+                m.Target && !desiredTargets.has(m.Target) ? [m.Target] : [],
+              );
+              const desiredPorts = new Set(desired.ports.map(formatPublish));
+              const portsToRemove = (current.Spec.EndpointSpec?.Ports ?? []).flatMap((p) =>
+                p.TargetPort !== undefined &&
+                !desiredPorts.has(
+                  formatPublish({
+                    external: p.PublishedPort,
+                    internal: p.TargetPort,
+                    protocol: p.Protocol,
+                    mode: p.PublishMode,
+                  }),
+                )
+                  ? // `--publish-rm` matches target, protocol and publish mode.
+                    [
+                      `target=${p.TargetPort},protocol=${p.Protocol ?? "tcp"},mode=${p.PublishMode ?? "ingress"}`,
+                    ]
+                  : [],
+              );
+              // A rollback exits 0 but a paused rollout exits 1, so the
+              // outcome is read from `UpdateStatus` either way.
+              const updateError = yield* docker.service
+                .update({
+                  context: desired.context,
+                  id: output.id,
+                  image,
+                  replicas: desired.replicas,
+                  "endpoint-mode": desired.endpointMode,
+                  // Attaching a network the service is already on fails, so
+                  // every attachment is detached and the desired set re-added.
+                  "network-rm": (current.Spec.TaskTemplate?.Networks ?? []).flatMap((n) =>
+                    n.Target ? [n.Target] : [],
+                  ),
+                  "network-add": desired.networks.map(formatNetwork),
+                  "constraint-rm": constraintsToRemove,
+                  "constraint-add": constraintsToAdd,
+                  "replicas-max-per-node": desired.maxReplicasPerNode,
+                  "update-parallelism": desired.updateConfig?.parallelism,
+                  "update-delay": desired.updateConfig?.delay,
+                  "update-monitor": desired.updateConfig?.monitor,
+                  "update-failure-action": desired.updateConfig?.failureAction,
+                  "update-max-failure-ratio": desired.updateConfig?.maxFailureRatio,
+                  "update-order": desired.updateConfig?.order,
+                  "rollback-parallelism": desired.rollbackConfig?.parallelism,
+                  "rollback-delay": desired.rollbackConfig?.delay,
+                  "rollback-monitor": desired.rollbackConfig?.monitor,
+                  "rollback-failure-action": desired.rollbackConfig?.failureAction,
+                  "rollback-max-failure-ratio": desired.rollbackConfig?.maxFailureRatio,
+                  "rollback-order": desired.rollbackConfig?.order,
+                  "restart-condition": desired.restartPolicy?.condition,
+                  "restart-delay": desired.restartPolicy?.delay,
+                  "restart-max-attempts": desired.restartPolicy?.maxAttempts,
+                  "restart-window": desired.restartPolicy?.window,
+                  "health-cmd": desired.healthcheck
+                    ? healthcheckCommand(desired.healthcheck.cmd)
                     : undefined,
-              });
+                  "no-healthcheck":
+                    desired.healthcheck !== undefined &&
+                    isHealthcheckDisabled(desired.healthcheck.cmd),
+                  "health-interval": desired.healthcheck?.interval,
+                  "health-timeout": desired.healthcheck?.timeout,
+                  "health-retries": desired.healthcheck?.retries,
+                  "health-start-period": desired.healthcheck?.startPeriod,
+                  "stop-grace-period": desired.stopGracePeriod,
+                  "mount-rm": mountsToRemove,
+                  "mount-add": desired.volumes.map(formatMount),
+                  // Re-adding a ref that is still attached conflicts on its
+                  // target, so every attached ref is removed and the desired
+                  // set re-added in the same update.
+                  "secret-rm": (spec?.Secrets ?? []).flatMap((s) =>
+                    s.SecretName ? [s.SecretName] : [],
+                  ),
+                  "secret-add": desired.secrets.map(formatRef),
+                  "config-rm": (spec?.Configs ?? []).flatMap((c) =>
+                    c.ConfigName ? [c.ConfigName] : [],
+                  ),
+                  "config-add": desired.configs.map(formatRef),
+                  "read-only": desired.readOnlyRootFs || undefined,
+                  "publish-rm": portsToRemove,
+                  "publish-add": desired.ports.map(formatPublish),
+                  "label-add": allDesiredLabels,
+                  "label-rm": labelsToRemove,
+                  "env-rm": envToRemove,
+                  "env-add": environment,
+                  args:
+                    desired.command.length > 0
+                      ? desired.command.concat(desired.args).join(" ")
+                      : undefined,
+                })
+                .pipe(
+                  Effect.as(undefined),
+                  Effect.catchTag("PlatformError", (error) => Effect.succeed(error)),
+                );
 
-              return toServiceAttributes(
-                yield* inspectOrDie(inspect, output.id, desired.context),
-                desired.context,
-                code,
-              );
+              const updated = yield* inspectOrDie(inspect, output.id, desired.context);
+              // Swarm clears `UpdateStatus` whenever it accepts an update, so
+              // any status here belongs to this update.
+              const status = updated.UpdateStatus;
+              if (
+                status?.State === "rollback_completed" ||
+                status?.State === "rollback_paused" ||
+                status?.State === "paused"
+              ) {
+                return yield* new DockerServiceUpdateFailed({
+                  service: updated.Spec.Name,
+                  state: status.State,
+                  reason: status.Message ?? "",
+                });
+              }
+              if (updateError) {
+                return yield* updateError;
+              }
+
+              // Best-effort: the service now runs the new content-addressed
+              // image, so drop the one built for the previous bundle.
+              if (output.code && output.code.hash !== resolved.codeHash) {
+                yield* docker.image
+                  .remove(output.image, true, desired.context)
+                  .pipe(Effect.catchCause(() => Effect.void));
+              }
+
+              return toServiceAttributes(updated, desired.context, code);
             }
           }
 
@@ -745,9 +859,7 @@ export const ServiceProvider = () =>
             image,
             replicas: desired.replicas,
             "endpoint-mode": desired.endpointMode,
-            network: desired.networks.map((n) =>
-              [`name=${n.name}`, ...(n.aliases ?? []).map((a) => `alias=${a}`)].join(","),
-            ),
+            network: desired.networks.map(formatNetwork),
             constraint: desired.constraints,
             "replicas-max-per-node": desired.maxReplicasPerNode,
             "placement-pref": desired.preferences,
@@ -866,6 +978,75 @@ const normalizeDesired = (id: string, props: ServiceProps, instanceId: string) =
     })),
   );
 
+type DesiredService = Effect.Success<ReturnType<typeof normalizeDesired>>;
+
+/**
+ * Fields `docker service update` changes in place. Swarm rolls the tasks
+ * onto the new spec following `updateConfig`, so `order: "start-first"` and
+ * `failureAction: "rollback"` apply.
+ */
+const inPlaceFields = new Set<keyof DesiredService>([
+  "image",
+  "replicas",
+  "environment",
+  "labels",
+  "networks",
+  "constraints",
+  "maxReplicasPerNode",
+  "updateConfig",
+  "rollbackConfig",
+  "restartPolicy",
+  "healthcheck",
+  "stopGracePeriod",
+  "volumes",
+  "secrets",
+  "configs",
+  "ports",
+]);
+
+/**
+ * Settings `service update` can change but not reset to the engine default:
+ * removing one, or a field inside one, replaces the service.
+ */
+const resettableFields = new Set<keyof DesiredService>([
+  "maxReplicasPerNode",
+  "updateConfig",
+  "rollbackConfig",
+  "restartPolicy",
+  "healthcheck",
+  "stopGracePeriod",
+]);
+
+const clearsSetting = (olds: unknown, news: unknown): boolean => {
+  if (olds === undefined) return false;
+  if (news === undefined) return true;
+  if (typeof olds !== "object" || olds === null) return false;
+  return Object.entries(olds).some(
+    ([key, value]) => value !== undefined && (news as Record<string, unknown>)[key] === undefined,
+  );
+};
+
+/**
+ * `--publish-rm` matches target, protocol and mode, and `--publish-add` skips
+ * a port already in the spec. Dropping one of several ports that share a
+ * target therefore drops the kept ones too, so that change replaces.
+ */
+const dropsSharedTargetPort = (olds: DesiredService, news: DesiredService): boolean => {
+  const kept = new Set(news.ports.map(formatPublish));
+  const key = (port: Service.PortMapping) => `${port.internal}/${port.protocol}/${port.mode}`;
+  const removedKeys = new Set(olds.ports.filter((p) => !kept.has(formatPublish(p))).map(key));
+  return olds.ports.some((p) => kept.has(formatPublish(p)) && removedKeys.has(key(p)));
+};
+
+const requiresReplacement = (olds: DesiredService, news: DesiredService): boolean =>
+  dropsSharedTargetPort(olds, news) ||
+  (Object.keys(news) as Array<keyof DesiredService>).some(
+    (key) =>
+      !deepEqual(olds[key], news[key]) &&
+      (!inPlaceFields.has(key) ||
+        (resettableFields.has(key) && clearsSetting(olds[key], news[key]))),
+  );
+
 const normalizeImageRef = (image: Service.Image): string =>
   typeof image === "string" ? image : image.imageRef;
 
@@ -928,6 +1109,9 @@ const formatMount = (volume: Service.VolumeMapping): string =>
     ...(volume.readOnly ? ["readonly=true"] : []),
   ].join(",");
 
+const formatNetwork = (network: Service.NetworkAttachment): string =>
+  [`name=${network.name}`, ...(network.aliases ?? []).map((a) => `alias=${a}`)].join(",");
+
 const formatRef = (ref: Service.SecretRef | Service.ConfigRef): string =>
   Object.entries(ref)
     .filter(([, value]) => value !== undefined)