@platforma-sdk/package-builder-lib 1.1.0

package/src/core/docker-conda.ts

@@ -0,0 +1,149 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type winston from "winston";
+
+import * as defaults from "../defaults";
+import * as paths from "./paths";
+import * as util from "./util";
+
+import type * as artifacts from "./schemas/artifacts";
+import { micromambaDownloadUrl } from "./conda/builder";
+import { validateCondaSpec } from "./conda/validate-spec";
+import { dockerfileAutogenPath } from "./docker";
+
+export const tmpSpecFile = "tmp-env-spec-88344b62d74b9307.yaml";
+
+export interface CondaOptions {
+  baseImageTag: string;
+  micromambaVersion: string;
+  frozenSpecFile: string;
+  pkg: string;
+}
+
+export interface DockerOptions {
+  context: string;
+  dockerfile: string;
+  entrypoint: string[];
+  pkg: string;
+}
+
+export interface CondaDockerOptions extends CondaOptions, DockerOptions {}
+
+function generateCondaDockerfileContent(options: CondaOptions, arch: util.ArchType): string {
+  // Read template from assets
+  const templatePath = paths.assets("conda-dockerfile.template");
+  const templateContent = fs.readFileSync(templatePath, "utf-8");
+
+  // Generate Dockerfile with dependencies
+  return templateContent
+    .replaceAll("${BASE_IMAGE_TAG}", options.baseImageTag)
+    .replaceAll("${MAMBA_ROOT_PREFIX}", path.posix.join(options.pkg, defaults.CONDA_DATA_LOCATION))
+    .replaceAll(
+      "${CONDA_PKGS_DIRS}",
+      path.posix.join(options.pkg, defaults.CONDA_DATA_LOCATION, "pkgs"),
+    )
+    .replaceAll(
+      "${MICROMAMBA_DOWNLOAD_URL}",
+      micromambaDownloadUrl(options.micromambaVersion, `linux-${arch}`),
+    )
+    .replaceAll("${PKG}", options.pkg)
+    .replaceAll("${TMP_SPEC_FILE}", tmpSpecFile)
+    .replaceAll("${FROZEN_SPEC_FILE}", options.frozenSpecFile);
+}
+
+export function prepareDockerOptions(
+  logger: winston.Logger,
+  currentPackageRoot: string,
+  artifactID: string,
+  buildParams: artifacts.condaType,
+  arch: util.ArchType,
+): DockerOptions {
+  logger.debug(
+    `Preparing Docker options for Conda package: ${buildParams.name} (id: ${artifactID})`,
+  );
+
+  const options = getDefaultCondaOptions();
+  options.micromambaVersion = buildParams["micromamba-version"];
+
+  if (buildParams.pkg) {
+    options.pkg = buildParams.pkg;
+  }
+
+  const platform: util.PlatformType = `linux-${arch}`;
+
+  if (!buildParams.roots) {
+    throw util.CLIError(
+      'Cannot prepare Docker options: package root directory is not specified. Please ensure the "root" property is set in the build parameters.',
+    );
+  }
+  if (!buildParams.roots[platform]) {
+    throw util.CLIError(
+      `Cannot prepare Docker options: ${platform} root directory is not specified. Please ensure the 'roots' property is set for artifact.`,
+    );
+  }
+
+  const contextDir = path.resolve(currentPackageRoot, buildParams.roots[platform]);
+  if (!fs.existsSync(contextDir)) {
+    fs.mkdirSync(contextDir, { recursive: true });
+  }
+
+  // Validate conda spec file before building
+  const srcSpecPath = path.join(currentPackageRoot, buildParams.spec);
+  logger.debug(`Validating conda spec file for forbidden channels...`);
+  try {
+    validateCondaSpec(logger, srcSpecPath);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(errorMessage);
+    throw util.CLIError(
+      `Cannot prepare Docker options for conda package '${artifactID}': ${errorMessage}`,
+    );
+  }
+
+  // Generate a temporary directory for the Dockerfile
+  const dockerfilePath = dockerfileAutogenPath(currentPackageRoot, artifactID);
+  const dockerfileDir = path.dirname(dockerfilePath);
+  fs.mkdirSync(dockerfileDir, { recursive: true });
+  logger.debug(`Created directory for autogenerated dockerfiles: ${dockerfileDir}`);
+
+  fs.copyFileSync(srcSpecPath, path.join(contextDir, tmpSpecFile));
+  logger.debug(`Copied spec file to context directory`);
+
+  const dockerfile = {
+    content: generateCondaDockerfileContent(options, arch),
+    path: dockerfilePath,
+  };
+
+  fs.writeFileSync(dockerfile.path, dockerfile.content);
+  logger.debug(`Written Dockerfile to: ${dockerfile.path}`);
+
+  const result: DockerOptions = {
+    dockerfile: dockerfile.path,
+    context: contextDir,
+    entrypoint: [],
+    pkg: options.pkg,
+  };
+
+  logger.debug(`Prepared Docker options: ${JSON.stringify(result)}`);
+  verifyDockerOptions(result);
+  return result;
+}
+
+function getDefaultCondaOptions(): CondaOptions {
+  return {
+    baseImageTag: defaults.CONDA_DOCKER_BASE_IMAGE,
+    micromambaVersion: defaults.CONDA_MICROMAMBA_VERSION,
+    frozenSpecFile: defaults.CONDA_FROZEN_ENV_SPEC_FILE,
+    pkg: defaults.DOCKER_PLACEHOLDER_PKG,
+  };
+}
+
+function verifyDockerOptions(options: DockerOptions) {
+  if (!fs.existsSync(options.dockerfile)) {
+    throw util.CLIError(`Dockerfile '${options.dockerfile}' not found`);
+  }
+
+  if (!fs.existsSync(options.context)) {
+    throw util.CLIError(`Context '${options.context}' not found`);
+  }
+}

package/src/core/docker-python.ts

@@ -0,0 +1,283 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type winston from "winston";
+
+import * as defaults from "../defaults";
+import * as paths from "./paths";
+import * as util from "./util";
+
+import type * as artifacts from "./schemas/artifacts";
+import { resolveRunEnvironment } from "./resolver";
+import { dockerfileAutogenPath } from "./docker";
+
+const PYTHON_VERSION_PATTERNS = {
+  PY3_PREFIX: /^3\./,
+  VERSION_FORMAT:
+    /^3\.\d+(?:\.\d+)?(?:[-+_][a-zA-Z0-9]+|(?:a|b|rc)\d+|[a-zA-Z]+\d+(?:\.[a-zA-Z0-9]+)*)*$/,
+  DOCKER_SEPARATOR: /@.*$/,
+  DOCKER_UNSAFE_CHARS: /[^A-Za-z0-9_.-]+/g,
+  MULTIPLE_SEPARATORS: /[-.]{2,}/g,
+  EDGE_SEPARATORS: /^[-.]+|[-.]+$/g,
+  DOCKER_TAG_FORMAT: /^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$/,
+};
+
+export interface PythonOptions {
+  baseImageTag: string;
+  toolset: string;
+  requirements: string;
+  pkg: string;
+  envVars: string[]; // custom environment variables set for run environment
+}
+
+export interface DockerOptions {
+  context: string;
+  dockerfile: string;
+  entrypoint: string[];
+  pkg: string;
+}
+
+export interface PythonDockerOptions extends PythonOptions, DockerOptions {}
+
+function generatePythonDockerfileContent(options: PythonOptions): string {
+  // Read template from assets
+  const templatePath = paths.assets("python-dockerfile.template");
+  const templateContent = fs.readFileSync(templatePath, "utf-8");
+
+  const envVars = options.envVars.map((envVar) => `ENV ${envVar}`).join("\n");
+
+  // Generate Dockerfile with dependencies
+  return templateContent
+    .replace(/\$\{RUNENV_ENVS\}/g, envVars)
+    .replace(/\$\{BASE_IMAGE_TAG\}/g, options.baseImageTag)
+    .replace(/\$\{REQUIREMENTS_PATH\}/g, options.requirements)
+    .replace(/\$\{REQUIREMENTS_FILENAME\}/g, path.basename(options.requirements))
+    .replace(/\$\{TOOLSET\}/g, options.toolset)
+    .replace(/\$\{PKG\}/g, options.pkg);
+}
+
+export function prepareDockerOptions(
+  logger: winston.Logger,
+  currentPackageRoot: string,
+  currentPackageName: string,
+  artifactID: string,
+  buildParams: artifacts.pythonType,
+): DockerOptions {
+  logger.debug(
+    `Preparing Docker options for Python package: ${buildParams.name} (id: ${artifactID})`,
+  );
+
+  const options = getDefaultPythonOptions();
+
+  const pythonInfo = getRunEnvironmentPythonInfo(
+    logger,
+    currentPackageRoot,
+    currentPackageName,
+    buildParams.environment,
+  );
+  if (pythonInfo.pythonVersion) {
+    logger.debug(`Extracted Python version from environment: ${pythonInfo.pythonVersion}`);
+    options.baseImageTag = pythonVersionToDockerTag(pythonInfo.pythonVersion);
+  } else {
+    logger.debug(`No Python version found in environment, using default: ${options.baseImageTag}`);
+  }
+  options.envVars = pythonInfo.envVars;
+
+  if (buildParams.dependencies) {
+    options.toolset = buildParams.dependencies.toolset;
+    options.requirements = buildParams.dependencies.requirements;
+  }
+
+  if (buildParams.pkg) {
+    options.pkg = buildParams.pkg;
+  }
+
+  if (!buildParams.root) {
+    throw util.CLIError(
+      'Cannot prepare Docker options: package root directory is not specified. Please ensure the "root" property is set in the build parameters.',
+    );
+  }
+  const contextDir = path.resolve(buildParams.root ?? currentPackageRoot);
+
+  options.requirements = path.join(contextDir, options.requirements);
+  const hasRequirements = fs.existsSync(options.requirements);
+
+  if (!hasRequirements) {
+    // If requirements.txt doesn't exist, create an empty one
+    fs.writeFileSync(options.requirements, "# No dependencies specified\n");
+    logger.warn(`Created empty requirements.txt at: ${options.requirements}`);
+  }
+  // If requirements.txt exists, use relative path for Docker COPY command
+  options.requirements = path.relative(contextDir, options.requirements);
+
+  // Generate a temporary directory for the Dockerfile
+  const dockerfilePath = dockerfileAutogenPath(currentPackageRoot, artifactID);
+
+  const dockerfileDir = path.dirname(dockerfilePath);
+  fs.mkdirSync(dockerfileDir, { recursive: true });
+  logger.debug(`Created temporary Docker directory: ${dockerfileDir}`);
+
+  const dockerfile = {
+    content: generatePythonDockerfileContent(options),
+    path: dockerfilePath,
+  };
+
+  fs.writeFileSync(dockerfile.path, dockerfile.content);
+  logger.debug(`Written Dockerfile to: ${dockerfile.path}`);
+
+  const result: DockerOptions = {
+    dockerfile: dockerfile.path,
+    context: contextDir,
+    entrypoint: [],
+    pkg: options.pkg,
+  };
+
+  logger.debug(`Prepared Docker options: ${JSON.stringify(result)}`);
+  verifyDockerOptions(result);
+  return result;
+}
+
+function normalizeDockerTag(candidate: string): string | undefined {
+  if (!candidate || typeof candidate !== "string") {
+    return undefined;
+  }
+
+  // First remove Docker-specific parts like @sha256:...
+  let normalized = candidate.replace(PYTHON_VERSION_PATTERNS.DOCKER_SEPARATOR, "");
+
+  // For cases like "3.12.6:latest", extract only the version part
+  if (normalized.includes(":")) {
+    normalized = normalized.split(":")[0];
+  }
+
+  // Clean up any remaining unsafe characters
+  normalized = normalized
+    .replace(PYTHON_VERSION_PATTERNS.DOCKER_UNSAFE_CHARS, "-")
+    .replace(PYTHON_VERSION_PATTERNS.MULTIPLE_SEPARATORS, "-")
+    .replace(PYTHON_VERSION_PATTERNS.EDGE_SEPARATORS, "");
+
+  return normalized || undefined;
+}
+
+function isValidPythonVersion(version: string): boolean {
+  return (
+    PYTHON_VERSION_PATTERNS.PY3_PREFIX.test(version) &&
+    PYTHON_VERSION_PATTERNS.VERSION_FORMAT.test(version)
+  );
+}
+
+function isValidDockerTag(tag: string): boolean {
+  return PYTHON_VERSION_PATTERNS.DOCKER_TAG_FORMAT.test(tag);
+}
+
+export function getRunEnvironmentPythonInfo(
+  logger: winston.Logger,
+  currentPackageRoot: string,
+  currentPackageName: string,
+  runEnvironmentID: artifacts.artifactIDString,
+  { normalizeForDocker = true }: { normalizeForDocker?: boolean } = {},
+): {
+  pythonVersion: string | undefined;
+  envVars: string[];
+} {
+  if (!runEnvironmentID) {
+    return {
+      pythonVersion: undefined,
+      envVars: [],
+    };
+  }
+
+  const environmentDescriptor = resolveRunEnvironment(
+    logger,
+    currentPackageRoot,
+    currentPackageName,
+    runEnvironmentID,
+    "python",
+  );
+
+  let pythonVersion: string | undefined = environmentDescriptor["python-version"];
+  const envVars = environmentDescriptor.envVars ?? [];
+  if (!pythonVersion) {
+    pythonVersion = undefined;
+    const trimmedInput = runEnvironmentID.trim();
+    if (!trimmedInput) {
+      return {
+        pythonVersion: undefined,
+        envVars,
+      };
+    }
+
+    const colonIndex = trimmedInput.indexOf(":");
+    if (colonIndex === -1 || colonIndex === trimmedInput.length - 1) {
+      return {
+        pythonVersion: undefined,
+        envVars,
+      };
+    }
+
+    pythonVersion = trimmedInput.slice(colonIndex + 1);
+    if (pythonVersion.startsWith("python")) {
+      return {
+        pythonVersion: undefined,
+        envVars,
+      };
+    }
+  }
+
+  if (!normalizeForDocker) {
+    return {
+      pythonVersion,
+      envVars,
+    };
+  }
+
+  const normalizedTag = normalizeDockerTag(pythonVersion);
+  if (!normalizedTag) {
+    return {
+      pythonVersion: undefined,
+      envVars,
+    };
+  }
+
+  if (!isValidPythonVersion(normalizedTag) || !isValidDockerTag(normalizedTag)) {
+    return {
+      pythonVersion: undefined,
+      envVars,
+    };
+  }
+
+  return {
+    pythonVersion: normalizedTag,
+    envVars,
+  };
+}
+
+function getDefaultPythonOptions(): PythonOptions {
+  return {
+    baseImageTag: defaults.PYTHON_DOCKER_BASE_IMAGE,
+    toolset: defaults.PYTHON_TOOLSET,
+    requirements: defaults.PYTHON_REQUIREMENTS_FILE,
+    pkg: defaults.DOCKER_PLACEHOLDER_PKG,
+    envVars: [],
+  };
+}
+
+function verifyDockerOptions(options: DockerOptions) {
+  if (!fs.existsSync(options.dockerfile)) {
+    throw util.CLIError(`Dockerfile '${options.dockerfile}' not found`);
+  }
+
+  if (!fs.existsSync(options.context)) {
+    throw util.CLIError(`Context '${options.context}' not found`);
+  }
+}
+
+function pythonVersionToDockerTag(pythonVersion: string): string {
+  const parts = pythonVersion.split(".");
+  if (parts.length > 2) {
+    const major = parts[0];
+    const minor = parts[1];
+    return `python:${major}.${minor}-slim`;
+  }
+
+  return `python:${pythonVersion}-slim`;
+}