use global dag client

Author: tsirysndr

ansible-lint/sdk/client.gen.ts

@@ -0,0 +1,46 @@
+import { log } from "../utils.ts";
+import { ErrorCodes, ErrorNames } from "./errors-codes.ts";
+
+export interface DaggerSDKErrorOptions {
+  cause?: Error;
+}
+
+/**
+ * The base error. Every other error inherits this error.
+ */
+export abstract class DaggerSDKError extends Error {
+  /**
+   * The name of the dagger error.
+   */
+  abstract readonly name: ErrorNames;
+
+  /**
+   * The dagger specific error code.
+   * Use this to identify dagger errors programmatically.
+   */
+  abstract readonly code: ErrorCodes;
+
+  /**
+   * The original error, which caused the DaggerSDKError.
+   */
+  cause?: Error;
+
+  protected constructor(message: string, options?: DaggerSDKErrorOptions) {
+    super(message);
+    this.cause = options?.cause;
+  }
+
+  /**
+   * @hidden
+   */
+  get [Symbol.toStringTag]() {
+    return this.name;
+  }
+
+  /**
+   * Pretty prints the error
+   */
+  printStackTrace() {
+    log(this.stack);
+  }
+}

ansible-lint/sdk/common/errors/DaggerSDKError.ts

@@ -0,0 +1,28 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.ts"
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.ts"
+
+interface DockerImageRefValidationErrorOptions extends DaggerSDKErrorOptions {
+  ref: string
+}
+
+/**
+ *  This error is thrown if the passed image reference does not pass validation and is not compliant with the
+ *  DockerImage constructor.
+ */
+export class DockerImageRefValidationError extends DaggerSDKError {
+  name = ERROR_NAMES.DockerImageRefValidationError
+  code = ERROR_CODES.DockerImageRefValidationError
+
+  /**
+   *  The docker image reference, which caused the error.
+   */
+  ref: string
+
+  /**
+   *  @hidden
+   */
+  constructor(message: string, options: DockerImageRefValidationErrorOptions) {
+    super(message, options)
+    this.ref = options?.ref
+  }
+}

ansible-lint/sdk/common/errors/DockerImageRefValidationError.ts

@@ -0,0 +1,31 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.ts";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.ts";
+
+interface EngineSessionConnectParamsParseErrorOptions
+  extends DaggerSDKErrorOptions {
+  parsedLine: string;
+}
+
+/**
+ * This error is thrown if the EngineSession does not manage to parse the required connection parameters from the session binary
+ */
+export class EngineSessionConnectParamsParseError extends DaggerSDKError {
+  name = ERROR_NAMES.EngineSessionConnectParamsParseError;
+  code = ERROR_CODES.EngineSessionConnectParamsParseError;
+
+  /**
+   *  the line, which caused the error during parsing, if the error was caused because of parsing.
+   */
+  parsedLine: string;
+
+  /**
+   * @hidden
+   */
+  constructor(
+    message: string,
+    options: EngineSessionConnectParamsParseErrorOptions
+  ) {
+    super(message, options);
+    this.parsedLine = options.parsedLine;
+  }
+}

ansible-lint/sdk/common/errors/EngineSessionConnectParamsParseError.ts

@@ -0,0 +1,31 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.ts";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.ts";
+
+interface EngineSessionConnectionTimeoutErrorOptions
+  extends DaggerSDKErrorOptions {
+  timeOutDuration: number;
+}
+
+/**
+ * This error is thrown if the EngineSession does not manage to parse the required port successfully because the sessions connection timed out.
+ */
+export class EngineSessionConnectionTimeoutError extends DaggerSDKError {
+  name = ERROR_NAMES.EngineSessionConnectionTimeoutError;
+  code = ERROR_CODES.EngineSessionConnectionTimeoutError;
+
+  /**
+   * The duration until the timeout occurred in ms.
+   */
+  timeOutDuration: number;
+
+  /**
+   * @hidden
+   */
+  constructor(
+    message: string,
+    options: EngineSessionConnectionTimeoutErrorOptions
+  ) {
+    super(message, options);
+    this.timeOutDuration = options.timeOutDuration;
+  }
+}

ansible-lint/sdk/common/errors/EngineSessionConnectionTimeoutError.ts

@@ -0,0 +1,20 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.ts";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.ts";
+
+type EngineSessionErrorOptions = DaggerSDKErrorOptions;
+
+/**
+ * This error is thrown if the EngineSession does not manage to parse the required port successfully because a EOF is read before any valid port.
+ * This usually happens if no connection can be established.
+ */
+export class EngineSessionError extends DaggerSDKError {
+  name = ERROR_NAMES.EngineSessionError;
+  code = ERROR_CODES.EngineSessionError;
+
+  /**
+   * @hidden
+   */
+  constructor(message: string, options?: EngineSessionErrorOptions) {
+    super(message, options);
+  }
+}

ansible-lint/sdk/common/errors/EngineSessionErrorOptions.ts

@@ -0,0 +1,54 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.ts";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.ts";
+
+interface ExecErrorOptions extends DaggerSDKErrorOptions {
+  cmd: string[];
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+/**
+ *  API error from an exec operation in a pipeline.
+ */
+export class ExecError extends DaggerSDKError {
+  name = ERROR_NAMES.ExecError;
+  code = ERROR_CODES.ExecError;
+
+  /**
+   *  The command that caused the error.
+   */
+  cmd: string[];
+
+  /**
+   *  The exit code of the command.
+   */
+  exitCode: number;
+
+  /**
+   * The stdout of the command.
+   */
+  stdout: string;
+
+  /**
+   * The stderr of the command.
+   */
+  stderr: string;
+
+  /**
+   *  @hidden
+   */
+  constructor(message: string, options: ExecErrorOptions) {
+    super(message, options);
+    this.cmd = options.cmd;
+    this.exitCode = options.exitCode;
+    this.stdout = options.stdout;
+    this.stderr = options.stderr;
+  }
+
+  toString(): string {
+    return `${super.toString()}\nStdout:\n${this.stdout}\nStderr:\n${
+      this.stderr
+    }`;
+  }
+}

ansible-lint/sdk/common/errors/ExecError.ts

@@ -0,0 +1,36 @@
+import { GraphQLRequestContext, GraphQLResponse } from "./types.ts";
+
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.ts";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.ts";
+
+interface GraphQLRequestErrorOptions extends DaggerSDKErrorOptions {
+  response: GraphQLResponse;
+  request: GraphQLRequestContext;
+}
+
+/**
+ *  This error originates from the dagger engine. It means that some error was thrown and sent back via GraphQL.
+ */
+export class GraphQLRequestError extends DaggerSDKError {
+  name = ERROR_NAMES.GraphQLRequestError;
+  code = ERROR_CODES.GraphQLRequestError;
+
+  /**
+   *  The query and variables, which caused the error.
+   */
+  requestContext: GraphQLRequestContext;
+
+  /**
+   *  the GraphQL response containing the error.
+   */
+  response: GraphQLResponse;
+
+  /**
+   *  @hidden
+   */
+  constructor(message: string, options: GraphQLRequestErrorOptions) {
+    super(message, options);
+    this.requestContext = options.request;
+    this.response = options.response;
+  }
+}

ansible-lint/sdk/common/errors/GraphQLRequestError.ts

@@ -0,0 +1,17 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.ts";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.ts";
+
+/**
+ *  This error is thrown if the dagger binary cannot be copied from the dagger docker image and copied to the local host.
+ */
+export class InitEngineSessionBinaryError extends DaggerSDKError {
+  name = ERROR_NAMES.InitEngineSessionBinaryError;
+  code = ERROR_CODES.InitEngineSessionBinaryError;
+
+  /**
+   *  @hidden
+   */
+  constructor(message: string, options?: DaggerSDKErrorOptions) {
+    super(message, options);
+  }
+}

ansible-lint/sdk/common/errors/InitEngineSessionBinaryError.ts

@@ -0,0 +1,17 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.ts";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.ts";
+
+/**
+ * This error is thrown when the compute function isn't awaited.
+ */
+export class NotAwaitedRequestError extends DaggerSDKError {
+  name = ERROR_NAMES.NotAwaitedRequestError;
+  code = ERROR_CODES.NotAwaitedRequestError;
+
+  /**
+   * @hidden
+   */
+  constructor(message: string, options?: DaggerSDKErrorOptions) {
+    super(message, options);
+  }
+}

ansible-lint/sdk/common/errors/NotAwaitedRequestError.ts

@@ -0,0 +1,27 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.ts";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.ts";
+
+interface TooManyNestedObjectsErrorOptions extends DaggerSDKErrorOptions {
+  response: unknown;
+}
+
+/**
+ *  Dagger only expects one response value from the engine. If the engine returns more than one value this error is thrown.
+ */
+export class TooManyNestedObjectsError extends DaggerSDKError {
+  name = ERROR_NAMES.TooManyNestedObjectsError;
+  code = ERROR_CODES.TooManyNestedObjectsError;
+
+  /**
+   *  the response containing more than one value.
+   */
+  response: unknown;
+
+  /**
+   * @hidden
+   */
+  constructor(message: string, options: TooManyNestedObjectsErrorOptions) {
+    super(message, options);
+    this.response = options.response;
+  }
+}

ansible-lint/sdk/common/errors/TooManyNestedObjectsError.ts

@@ -0,0 +1,17 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.ts";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.ts";
+
+/**
+ *  This error is thrown if the dagger SDK does not identify the error and just wraps the cause.
+ */
+export class UnknownDaggerError extends DaggerSDKError {
+  name = ERROR_NAMES.UnknownDaggerError;
+  code = ERROR_CODES.UnknownDaggerError;
+
+  /**
+   * @hidden
+   */
+  constructor(message: string, options: DaggerSDKErrorOptions) {
+    super(message, options);
+  }
+}

ansible-lint/sdk/common/errors/UnknownDaggerError.ts

@@ -0,0 +1,63 @@
+export const ERROR_CODES = {
+  /**
+   * {@link GraphQLRequestError}
+   */
+  GraphQLRequestError: "D100",
+
+  /**
+   * {@link UnknownDaggerError}
+   */
+  UnknownDaggerError: "D101",
+
+  /**
+   * {@link TooManyNestedObjectsError}
+   */
+  TooManyNestedObjectsError: "D102",
+
+  /**
+   * {@link EngineSessionConnectParamsParseError}
+   */
+  EngineSessionConnectParamsParseError: "D103",
+
+  /**
+   * {@link EngineSessionConnectionTimeoutError}
+   */
+  EngineSessionConnectionTimeoutError: "D104",
+
+  /**
+   * {@link EngineSessionError}
+   */
+  EngineSessionError: "D105",
+
+  /**
+   * {@link InitEngineSessionBinaryError}
+   */
+  InitEngineSessionBinaryError: "D106",
+
+  /**
+   * {@link DockerImageRefValidationError}
+   */
+  DockerImageRefValidationError: "D107",
+
+  /**
+   * {@link NotAwaitedRequestError}
+   */
+  NotAwaitedRequestError: "D108",
+
+  /**
+   * (@link ExecError}
+   */
+  ExecError: "D109",
+} as const
+
+type ErrorCodesType = typeof ERROR_CODES
+export type ErrorNames = keyof ErrorCodesType
+export type ErrorCodes = ErrorCodesType[ErrorNames]
+
+type ErrorNamesMap = { readonly [Key in ErrorNames]: Key }
+export const ERROR_NAMES: ErrorNamesMap = (
+  Object.keys(ERROR_CODES) as Array<ErrorNames>
+).reduce<ErrorNamesMap>(
+  (obj, item) => ({ ...obj, [item]: item }),
+  {} as ErrorNamesMap
+)