@sshkeda/task 0.0.0-stage → 1.0.0

package/src/lib/worker-thread/internal/answer-main-thread-messages.ts

@@ -0,0 +1,141 @@
+import { Cause, Clock, Deferred, Effect, Exit, Logger, Result, Schema, Tracer } from "effect";
+import { RpcServer } from "effect/rpc";
+
+import { TASK_ERROR_FIELDS } from "../../../shared/error-fields.ts";
+import { reportCause } from "../../../shared/report-cause.ts";
+import {
+  describeCauseMessage,
+  THROWN_VALUE_WITHOUT_MESSAGE,
+} from "../../../shared/report-errors.ts";
+import { TaskEvent, TaskFiberResult, TaskWorkerRpcs } from "../../../shared/rpc.ts";
+import type { StartTaskFiber } from "../../../shared/rpc.ts";
+import { makeTraceFile } from "../../../shared/write-trace-file.ts";
+import {
+  forgetEndedProcessGroups,
+  killTaskProcessGroups,
+} from "../../kill-leftover-processes/index.ts";
+import { makeTaskBodyRecord } from "../shared/define-task-body-record.ts";
+import { WorkerState, reportToMainThread } from "../shared/provide-worker-state.ts";
+import { describeCleanupFailure, describeTaskBodyResult } from "./describe-task-body-result.ts";
+import { runTaskBody } from "./run-task-body.ts";
+
+class TaskResultNotHandedOver extends Schema.TaggedError<TaskResultNotHandedOver>()(
+  "TaskResultNotHandedOver",
+  { ...TASK_ERROR_FIELDS, taskName: Schema.String, cause: Schema.Defect() },
+) {
+  public override get message() {
+    return `could not hand the result of "${this.taskName}" to the main thread because ${describeCauseMessage(this.cause)}`;
+  }
+}
+
+const describeResultNotHandedOver = (notHandedOver: TaskResultNotHandedOver) =>
+  TaskFiberResult.cases.Failed.make(reportCause(Cause.fail(notHandedOver)));
+
+const endTaskBody = Effect.fn("endTaskBody")(function* (
+  startMessage: typeof StartTaskFiber.Type,
+  body: ReturnType<typeof makeTaskBodyRecord>,
+  taskExit: Exit.Exit<unknown, unknown>,
+) {
+  const elapsedMilliseconds = (yield* Clock.currentTimeMillis) - body.startedAtMilliseconds;
+  const workerState = yield* WorkerState;
+  const cleanupExit = yield* Effect.exit(
+    killTaskProcessGroups(body.startedProcessGroups, startMessage.taskName, (processes) =>
+      workerState.claimProcessesToReport(startMessage.taskName, processes),
+    ).pipe(Effect.flatMap(forgetEndedProcessGroups(body.startedProcessGroups))),
+  );
+  const sendTaskFiberEnded = (result: typeof TaskFiberResult.Type) =>
+    reportToMainThread(
+      TaskEvent.cases.TaskFiberEnded.make({
+        taskName: startMessage.taskName,
+        result,
+        logs: body.logs,
+      }),
+    );
+  yield* Effect.suspend((): Effect.Effect<typeof TaskFiberResult.Type> => {
+    const cleanupFailure = describeCleanupFailure(body, cleanupExit, taskExit);
+    return cleanupFailure === null
+      ? describeTaskBodyResult(
+          startMessage,
+          body,
+          Exit.isFailure(cleanupExit) ? cleanupExit : taskExit,
+          elapsedMilliseconds,
+        )
+      : Effect.succeed(cleanupFailure);
+  }).pipe(
+    Effect.flatMap(sendTaskFiberEnded),
+    Effect.matchCauseEffect({
+      onFailure: (failureCause) => {
+        const defect = Cause.findDefect(failureCause);
+        return Result.isFailure(defect)
+          ? Effect.failCause(defect.failure)
+          : Effect.try(() =>
+              describeResultNotHandedOver(
+                new TaskResultNotHandedOver({
+                  taskName: startMessage.taskName,
+                  cause: defect.success,
+                }),
+              ),
+            ).pipe(
+              Effect.catchTag("UnknownError", () =>
+                Effect.sync(() =>
+                  describeResultNotHandedOver(
+                    new TaskResultNotHandedOver({
+                      taskName: startMessage.taskName,
+                      cause: THROWN_VALUE_WITHOUT_MESSAGE,
+                    }),
+                  ),
+                ),
+              ),
+              Effect.flatMap(sendTaskFiberEnded),
+            );
+      },
+      onSuccess: (success) => Effect.succeed(success),
+    }),
+  );
+});
+
+const startTaskFiber = Effect.fn("startTaskFiber")(function* (start: typeof StartTaskFiber.Type) {
+  const workerState = yield* WorkerState;
+  const body = makeTaskBodyRecord();
+  yield* workerState.startTaskBodyFiber(
+    start.taskName,
+    runTaskBody(start, body).pipe(
+      Effect.withParentSpan(Tracer.externalSpan({ traceId: start.traceId, spanId: start.spanId })),
+      Effect.onExit((taskExit) => endTaskBody(start, body, taskExit)),
+    ),
+  );
+});
+
+const serveUntilExitRequested = Effect.gen(function* () {
+  const workerState = yield* WorkerState;
+  const exitRequested = yield* Deferred.make<void>();
+  const handlers = yield* TaskWorkerRpcs.toHandlers({
+    StartTaskFiber: startTaskFiber,
+    StopTaskFiber: (stop) => workerState.requestTaskBodyInterruption(stop.taskName),
+    AnswerIfResponsive: () => Effect.void,
+    ExitWorker: () => Deferred.done(exitRequested, Exit.void).pipe(Effect.asVoid),
+  });
+  yield* RpcServer.make(TaskWorkerRpcs, { disableTracing: true }).pipe(
+    Effect.provideContext(handlers),
+    Effect.interruptible,
+    Effect.forkScoped,
+  );
+  yield* Deferred.await(exitRequested);
+});
+
+export const serveTheMainThread = Effect.gen(function* () {
+  const workerState = yield* WorkerState;
+  const traceFile = yield* makeTraceFile({
+    traceFilePath: workerState.traceFilePath,
+    thread: "worker",
+    maxBatchSize: 1,
+    onIncomplete: (reason) =>
+      Effect.sync(() => {
+        workerState.reportToMainThreadNow(TaskEvent.cases.TraceWriteFailed.make({ reason }));
+      }),
+  });
+  yield* serveUntilExitRequested.pipe(
+    Effect.provideService(Tracer.Tracer, traceFile.tracer),
+    Effect.provideService(Logger.CurrentLoggers, new Set([traceFile.logger])),
+  );
+});

package/src/lib/worker-thread/internal/describe-task-body-result.ts

@@ -0,0 +1,91 @@
+import { Cause, Effect, Exit, Option, Schema } from "effect";
+
+import { reportCause } from "../../../shared/report-cause.ts";
+import { TaskFiberResult } from "../../../shared/rpc.ts";
+import type { StartTaskFiber } from "../../../shared/rpc.ts";
+import { failuresOfCause } from "../../../shared/select-cause-reasons.ts";
+import { isAwaitedTasksFailure } from "../../../shared/task-errors.ts";
+import { CommandFailed } from "../../errors/index.ts";
+import { decodeTaskResultJson } from "../shared/decode-task-result-json.ts";
+import type { makeTaskBodyRecord } from "../shared/define-task-body-record.ts";
+
+const isCommandFailed = Schema.is(CommandFailed);
+
+export const describeBodyFailure = (cause: Cause.Cause<unknown>) => {
+  const failureCause = failuresOfCause(cause);
+  const hasOnlyOneFailure = failureCause.reasons.length === 1;
+  const firstFailure = Cause.findErrorOption(failureCause);
+  const awaitedTasksFailure = Option.filter(firstFailure, isAwaitedTasksFailure);
+  const hasOnlyAwaitedFailure = hasOnlyOneFailure && Option.isSome(awaitedTasksFailure);
+  if (hasOnlyAwaitedFailure) {
+    return TaskFiberResult.cases.AwaitedTasksFailed.make({ failure: awaitedTasksFailure.value });
+  }
+  const failedCommand = Option.filter(firstFailure, isCommandFailed);
+  const hasOnlyCommandFailure = hasOnlyOneFailure && Option.isSome(failedCommand);
+  return TaskFiberResult.cases.Failed.make({
+    ...reportCause(cause),
+    ...(hasOnlyCommandFailure ? { failedCommandExitCode: failedCommand.value.code } : {}),
+  });
+};
+
+export const describeTaskBodyResult = (
+  startMessage: typeof StartTaskFiber.Type,
+  body: ReturnType<typeof makeTaskBodyRecord>,
+  taskExit: Exit.Exit<unknown, unknown>,
+  elapsedMilliseconds: number,
+) => {
+  if (Exit.isSuccess(taskExit)) {
+    return decodeTaskResultJson(startMessage.taskName, "returned", taskExit.value).pipe(
+      Effect.map((returnedValue) =>
+        TaskFiberResult.cases.Returned.make({
+          ...(returnedValue === undefined ? {} : { value: returnedValue }),
+          elapsedMilliseconds,
+        }),
+      ),
+      Effect.catchTag("TaskResultNotJson", (error) =>
+        Effect.succeed(TaskFiberResult.cases.Failed.make(reportCause(Cause.fail(error)))),
+      ),
+    );
+  }
+  if (!Cause.hasInterruptsOnly(taskExit.cause)) {
+    return Effect.succeed(describeBodyFailure(taskExit.cause));
+  }
+  return Effect.succeed(
+    Option.match(body.causeReportedBeforeCleanup, {
+      onNone: () => TaskFiberResult.cases.Interrupted.make({}),
+      onSome: describeBodyFailure,
+    }),
+  );
+};
+
+const failureValueOf = (reason: Cause.Reason<unknown>): unknown => {
+  if (Cause.isFailReason(reason)) {
+    return reason.error;
+  }
+  return Cause.isDieReason(reason) ? reason.defect : reason;
+};
+
+export const describeCleanupFailure = (
+  body: ReturnType<typeof makeTaskBodyRecord>,
+  cleanupExit: Exit.Exit<unknown, unknown>,
+  taskExit: Exit.Exit<unknown, unknown>,
+) => {
+  if (Option.isNone(body.causeReportedBeforeCleanup)) {
+    return null;
+  }
+  const causeReportedBeforeCleanup = body.causeReportedBeforeCleanup.value;
+  const reportedFailureValues = new Set(causeReportedBeforeCleanup.reasons.map(failureValueOf));
+  const reasonsAddedByFinalizers = Exit.isFailure(taskExit)
+    ? taskExit.cause.reasons.filter(
+        (reason) =>
+          !Cause.isInterruptReason(reason) && !reportedFailureValues.has(failureValueOf(reason)),
+      )
+    : [];
+  const reasonsOfProcessCleanup = Exit.isFailure(cleanupExit) ? cleanupExit.cause.reasons : [];
+  const cleanupFailureReasons = [...reasonsOfProcessCleanup, ...reasonsAddedByFinalizers];
+  return cleanupFailureReasons.length === 0
+    ? null
+    : TaskFiberResult.cases.CleanupFailed.make(
+        reportCause(Cause.fromReasons(cleanupFailureReasons)),
+      );
+};

package/src/lib/worker-thread/internal/name-config-key-not-set.ts

@@ -0,0 +1,57 @@
+import { Config, Effect, Exit, Option, Schema, SchemaAST, SchemaIssue } from "effect";
+
+import {
+  nameConfigKey,
+  nameEnvironmentConfigVariable,
+  observeConfigLoads,
+} from "../../../shared/name-config-key.ts";
+import { ConfigKeyNotSet } from "../../../shared/task-errors.ts";
+
+const isConfigError = Schema.is(Schema.instanceOf(Config.ConfigError));
+
+const decodeConfigErrorAtPath = Schema.decodeUnknownOption(
+  Schema.Struct({ cause: Schema.Struct({ issue: Schema.instanceOf(SchemaIssue.Pointer) }) }),
+);
+
+const expectsManyVariables = (issue: SchemaIssue.Issue) =>
+  issue instanceof SchemaIssue.InvalidType &&
+  (SchemaAST.isObjects(issue.ast) || SchemaAST.isArrays(issue.ast));
+
+export const nameConfigKeyNotSet = <Success, Failure, Services>(
+  effect: Effect.Effect<Success, Failure, Services>,
+) =>
+  Effect.suspend(() => {
+    const missingKeys = new Map<string, { readonly readsRuntimeConfigProvider: boolean }>();
+    return effect.pipe(
+      observeConfigLoads(({ configPath, readsRuntimeConfigProvider, loaded }) => {
+        const loadedNothing = Exit.isSuccess(loaded) && loaded.value === undefined;
+        if (loadedNothing) {
+          missingKeys.set(nameConfigKey(configPath), { readsRuntimeConfigProvider });
+        }
+      }),
+      Effect.mapError((failure): ConfigKeyNotSet | Failure => {
+        if (!isConfigError(failure)) {
+          return failure;
+        }
+        const configError = failure;
+        const decodedConfigError = decodeConfigErrorAtPath(configError);
+        if (Option.isNone(decodedConfigError)) {
+          return configError;
+        }
+        const pointer = decodedConfigError.value.cause.issue;
+        const configPath = pointer.path.map(String);
+        const missing = missingKeys.get(nameConfigKey(configPath));
+        if (missing === undefined) {
+          return configError;
+        }
+        const namesOneEnvironmentConfigVariable =
+          missing.readsRuntimeConfigProvider && !expectsManyVariables(pointer.issue);
+        return new ConfigKeyNotSet({
+          configKey: nameConfigKey(configPath),
+          environmentConfigVariable: namesOneEnvironmentConfigVariable
+            ? nameEnvironmentConfigVariable(configPath)
+            : null,
+        });
+      }),
+    );
+  });

package/src/lib/worker-thread/internal/run-task-body.ts

@@ -0,0 +1,117 @@
+import { Effect, Exit, Schema, Cause, Clock, Option } from "effect";
+
+import {
+  InsideTaskBody,
+  markImportingTaskModule,
+} from "../../../shared/mark-task-worker-thread-contexts.ts";
+import { TASK_TRACE_LABEL_PREFIX } from "../../../shared/names-from-package-json.ts";
+import { findTasksMadeWithName } from "../../../shared/record-tasks-made.ts";
+import { CauseWithoutFailure } from "../../../shared/report-errors.ts";
+import { TaskEvent } from "../../../shared/rpc.ts";
+import type { StartTaskFiber } from "../../../shared/rpc.ts";
+import { runInChildFiberAndJoin } from "../../../shared/run-in-child-fiber-and-join.ts";
+import { RunCalledDuringImport, TaskModuleImportFailed } from "../../../shared/task-errors.ts";
+import { provideTaskServices } from "../lib/provide-task-services/index.ts";
+import type { makeTaskBodyRecord } from "../shared/define-task-body-record.ts";
+import { WorkerState, reportToMainThread } from "../shared/provide-worker-state.ts";
+import {
+  TaskNotRegisteredInWorker,
+  TaskRegisteredAgainInWorker,
+} from "../shared/worker-thread-errors.ts";
+import { describeBodyFailure } from "./describe-task-body-result.ts";
+import { nameConfigKeyNotSet } from "./name-config-key-not-set.ts";
+
+const isRunCalledDuringImport = Schema.is(RunCalledDuringImport);
+
+export const runTaskBody = Effect.fn("runTaskBody")(
+  function* (
+    startMessage: typeof StartTaskFiber.Type,
+    body: ReturnType<typeof makeTaskBodyRecord>,
+  ) {
+    yield* reportToMainThread(
+      TaskEvent.cases.TaskFiberLoading.make({ taskName: startMessage.taskName }),
+    );
+    yield* markImportingTaskModule(
+      Effect.tryPromise({
+        try: () => import(startMessage.taskFilePath),
+        catch: (cause) =>
+          isRunCalledDuringImport(cause)
+            ? cause
+            : new TaskModuleImportFailed({ filePath: startMessage.taskFilePath, cause }),
+      }),
+    );
+    const tasksMade = findTasksMadeWithName(startMessage.taskName);
+    const [task] = tasksMade;
+    if (task === undefined) {
+      return yield* new TaskNotRegisteredInWorker({
+        taskName: startMessage.taskName,
+        filePath: startMessage.taskFilePath,
+      });
+    }
+    if (tasksMade.length > 1) {
+      return yield* new TaskRegisteredAgainInWorker({
+        taskName: startMessage.taskName,
+        filePath: startMessage.taskFilePath,
+        madeCount: tasksMade.length,
+      });
+    }
+    body.startedAtMilliseconds = yield* Clock.currentTimeMillis;
+    yield* reportToMainThread(
+      TaskEvent.cases.TaskFiberStarted.make({ taskName: startMessage.taskName }),
+    );
+    const workerState = yield* WorkerState;
+    return yield* Effect.uninterruptibleMask((restore) =>
+      restore(task.body).pipe(
+        nameConfigKeyNotSet,
+        Effect.provideService(InsideTaskBody, true),
+        Effect.onExit((bodyExit) =>
+          Effect.gen(function* () {
+            const endedWithOnlyInterrupts =
+              Exit.isFailure(bodyExit) && Cause.hasInterruptsOnly(bodyExit.cause);
+            if (!endedWithOnlyInterrupts) {
+              return;
+            }
+            if (yield* workerState.wasAskedToStop(startMessage.taskName)) {
+              return;
+            }
+            const interruptedItself = Cause.fail(
+              new CauseWithoutFailure({ details: Cause.pretty(bodyExit.cause) }),
+            );
+            body.causeReportedBeforeCleanup = Option.some(interruptedItself);
+            yield* reportToMainThread(
+              TaskEvent.cases.TaskFiberFailedBeforeCleanup.make({
+                taskName: startMessage.taskName,
+                failure: describeBodyFailure(interruptedItself),
+              }),
+            );
+          }),
+        ),
+        Effect.tapCause((cause) => {
+          if (Cause.hasInterruptsOnly(cause)) {
+            return Effect.void;
+          }
+          body.causeReportedBeforeCleanup = Option.some(cause);
+          return reportToMainThread(
+            TaskEvent.cases.TaskFiberFailedBeforeCleanup.make({
+              taskName: startMessage.taskName,
+              failure: describeBodyFailure(cause),
+            }),
+          );
+        }),
+      ),
+    );
+  },
+  (effect, startMessage, body) =>
+    Effect.gen(function* () {
+      const workerState = yield* WorkerState;
+      yield* Effect.annotateCurrentSpan({
+        [`${TASK_TRACE_LABEL_PREFIX}.task`]: startMessage.taskName,
+        [`${TASK_TRACE_LABEL_PREFIX}.worker`]: workerState.workerId,
+      });
+      return yield* effect.pipe(
+        Effect.scoped,
+        runInChildFiberAndJoin,
+        provideTaskServices(startMessage, workerState, body),
+      );
+    }),
+);

package/src/lib/worker-thread/internal/serve-on-the-parent-port.ts

@@ -0,0 +1,63 @@
+import { parentPort } from "node:worker_threads";
+
+import { Deferred, Effect, Exit, FiberSet, Layer } from "effect";
+import { WorkerRunner } from "effect/workers";
+import { WorkerError, WorkerSpawnError } from "effect/workers/WorkerError";
+
+export const ParentPortWorkerRunnerLive = Layer.succeed(WorkerRunner.WorkerRunnerPlatform)({
+  start: <Outgoing, Incoming>(): Effect.Effect<
+    WorkerRunner.WorkerRunner<Outgoing, Incoming>,
+    WorkerError
+  > =>
+    Effect.gen(function* () {
+      const port = yield* Effect.fromNullishOr(parentPort).pipe(
+        Effect.mapError(
+          () =>
+            new WorkerError({
+              reason: new WorkerSpawnError({ message: "not running in a worker thread" }),
+            }),
+        ),
+      );
+      const sendUnsafe = (_portId: number, message: Outgoing) => {
+        port.postMessage([1, message]);
+      };
+      return {
+        run: <Success, Failure, Services>(
+          handler: (
+            portId: number,
+            message: Incoming,
+          ) => Effect.Effect<Success, Failure, Services> | void,
+        ) =>
+          Effect.gen(function* () {
+            const runInWorkerScope = yield* FiberSet.makeRuntime<Services, Success, Failure>();
+            const closed = yield* Deferred.make<void>();
+            const onMessage = (message: WorkerRunner.PlatformMessage<Incoming>) => {
+              if (message[0] === 1) {
+                Deferred.doneUnsafe(closed, Exit.void);
+                return;
+              }
+              const handled = handler(0, message[1]);
+              if (Effect.isEffect(handled)) {
+                runInWorkerScope(handled);
+              }
+            };
+            yield* Effect.acquireRelease(
+              Effect.sync(() => {
+                port.on("message", onMessage);
+                port.postMessage([0]);
+              }),
+              () =>
+                Effect.sync(() => {
+                  port.off("message", onMessage);
+                }),
+            );
+            yield* Deferred.await(closed);
+          }).pipe(Effect.scoped),
+        send: (portId: number, message: Outgoing) =>
+          Effect.sync(() => {
+            sendUnsafe(portId, message);
+          }),
+        sendUnsafe,
+      };
+    }),
+});

package/src/lib/worker-thread/internal/start-worker-thread.ts

@@ -0,0 +1,41 @@
+import { parentPort } from "node:worker_threads";
+
+import * as BunCrypto from "@effect/platform-bun/BunCrypto";
+import * as BunServices from "@effect/platform-bun/BunServices";
+import { Layer, Effect, Exit } from "effect";
+import { FetchHttpClient } from "effect/http";
+import { OtlpExporter, OtlpSerialization } from "effect/observability";
+import { RpcServer } from "effect/rpc";
+
+import { runtimeConfigProviderLayer } from "../../../shared/read-environment-config.ts";
+import { WorkerStateLive } from "../shared/provide-worker-state.ts";
+import { serveTheMainThread } from "./answer-main-thread-messages.ts";
+import { ParentPortWorkerRunnerLive } from "./serve-on-the-parent-port.ts";
+
+const workerThreadLayer = WorkerStateLive.pipe(
+  Layer.provideMerge(RpcServer.layerProtocolWorkerRunner),
+  Layer.provide(ParentPortWorkerRunnerLive),
+  Layer.provideMerge(
+    Layer.mergeAll(
+      BunServices.layer,
+      BunCrypto.layerDigest,
+      BunCrypto.layerSecureRandom,
+      FetchHttpClient.layer,
+      runtimeConfigProviderLayer,
+      OtlpExporter.layerFlusher,
+      OtlpSerialization.layerJson,
+    ),
+  ),
+);
+
+export const startWorkerThread = () => {
+  if (parentPort !== null) {
+    Effect.runFork(
+      serveTheMainThread.pipe(
+        Effect.provide(workerThreadLayer),
+        Effect.scoped,
+        Effect.onExit((exit) => Effect.sync(() => process.exit(Exit.isSuccess(exit) ? 0 : 1))),
+      ),
+    );
+  }
+};

package/src/lib/worker-thread/lib/provide-task-services/index.ts

@@ -0,0 +1 @@
+export { provideTaskServices } from "./internal/provide-task-services.ts";

package/src/lib/worker-thread/lib/provide-task-services/internal/make-task-logger.ts

@@ -0,0 +1,34 @@
+import { Array as Arrays, Logger, Formatter } from "effect";
+
+import { formatCauseLines } from "../../../../../shared/format-error-lines.ts";
+import { prefixLines } from "../../../../../shared/format-task-lines.ts";
+import { waitWhileTaskLogsAreHeld } from "../../../../../shared/hold-task-logs.ts";
+import { TaskEvent } from "../../../../../shared/rpc.ts";
+import type { StartTaskFiber } from "../../../../../shared/rpc.ts";
+import type { makeTaskBodyRecord } from "../../../shared/define-task-body-record.ts";
+
+export const makeTaskLogger = (
+  startMessage: typeof StartTaskFiber.Type,
+  body: ReturnType<typeof makeTaskBodyRecord>,
+  taskLogHold: Int32Array,
+  reportToMainThreadNow: (event: typeof TaskEvent.Type) => void,
+) =>
+  Logger.make((logEntry) => {
+    const text = Arrays.ensure(logEntry.message)
+      .map((part) => (typeof part === "string" ? part : Formatter.format(part)))
+      .join(" ");
+    const line = [
+      ...(text === "" ? [] : [text]),
+      ...(logEntry.cause.reasons.length === 0
+        ? []
+        : [formatCauseLines(logEntry.cause, startMessage.taskName)]),
+    ].join("\n");
+    body.logs.push(line);
+    waitWhileTaskLogsAreHeld(taskLogHold);
+    reportToMainThreadNow(
+      TaskEvent.cases.StandardErrorLineRequested.make({
+        logLevel: logEntry.logLevel,
+        text: prefixLines(startMessage.taskName, line),
+      }),
+    );
+  });

package/src/lib/worker-thread/lib/provide-task-services/internal/provide-task-services.ts

@@ -0,0 +1,86 @@
+import { Effect, FileSystem, Logger, Path } from "effect";
+import { ChildProcessSpawner } from "effect/process";
+
+import { TASK_TRACE_LABEL_PREFIX } from "../../../../../shared/names-from-package-json.ts";
+import { TaskEvent } from "../../../../../shared/rpc.ts";
+import type { StartTaskFiber } from "../../../../../shared/rpc.ts";
+import { Serving, Tasks } from "../../../../../shared/task-services.ts";
+import { decodeTaskResultJson } from "../../../shared/decode-task-result-json.ts";
+import type { OptionalJson } from "../../../shared/decode-task-result-json.ts";
+import type { makeTaskBodyRecord } from "../../../shared/define-task-body-record.ts";
+import { reportToMainThread, WorkerState } from "../../../shared/provide-worker-state.ts";
+import { makeTaskLogger } from "./make-task-logger.ts";
+import { provideTaskStdio } from "./read-standard-input-from-main-thread.ts";
+import { resolvePathsFromPackageDirectory } from "./resolve-paths-from-package-directory.ts";
+import { runCommandsInPackageDirectory } from "./run-commands-in-package-directory.ts";
+import { spawnReportedProcess } from "./spawn-reported-process.ts";
+
+const serve = (startMessage: typeof StartTaskFiber.Type, served: typeof OptionalJson.Type) =>
+  reportToMainThread(
+    TaskEvent.cases.TaskFiberServed.make({
+      taskName: startMessage.taskName,
+      ...(served === undefined ? {} : { value: served }),
+    }),
+  ).pipe(Effect.andThen(Effect.never));
+
+export const provideTaskServices =
+  (
+    startMessage: typeof StartTaskFiber.Type,
+    workerState: WorkerState["Service"],
+    body: ReturnType<typeof makeTaskBodyRecord>,
+  ) =>
+  <Success, Failure, Services>(effect: Effect.Effect<Success, Failure, Services>) =>
+    Effect.gen(function* () {
+      const { fileSystem, path } = resolvePathsFromPackageDirectory(
+        yield* Path.Path,
+        yield* FileSystem.FileSystem,
+        startMessage.taskPackageDirectoryPath,
+      );
+      return yield* effect.pipe(
+        provideTaskStdio(startMessage, workerState),
+        Effect.provideService(Path.Path, path),
+        Effect.provideService(FileSystem.FileSystem, fileSystem),
+        Effect.provideService(
+          Tasks,
+          Tasks.of({
+            requestResult: (dependencyTaskDefinition) =>
+              workerState.requestDependencyTaskResult(
+                dependencyTaskDefinition.name,
+                startMessage.taskName,
+              ),
+          }),
+        ),
+        Effect.provideService(
+          Serving,
+          Serving.of({
+            serve: (servedValue) =>
+              decodeTaskResultJson(startMessage.taskName, "served", servedValue).pipe(
+                Effect.flatMap((served) => serve(startMessage, served)),
+                Effect.provideService(WorkerState, workerState),
+              ),
+          }),
+        ),
+        Effect.provideService(
+          ChildProcessSpawner.ChildProcessSpawner,
+          runCommandsInPackageDirectory(path, startMessage.taskPackageDirectoryPath, (command) =>
+            spawnReportedProcess(startMessage, body, command).pipe(
+              Effect.provideService(WorkerState, workerState),
+            ),
+          ),
+        ),
+        Effect.provideService(
+          Logger.CurrentLoggers,
+          new Set([
+            ...(yield* Logger.CurrentLoggers),
+            makeTaskLogger(
+              startMessage,
+              body,
+              workerState.taskLogHold,
+              workerState.reportToMainThreadNow,
+            ),
+          ]),
+        ),
+        Effect.annotateLogs(`${TASK_TRACE_LABEL_PREFIX}.task`, startMessage.taskName),
+        workerState.provideRuntimeServices,
+      );
+    });