mirror of
https://github.com/game-ci/unity-builder.git
synced 2026-06-08 06:53:57 -07:00
feat(artifacts): complete generic artifact system with upload handlers, tests, and action integration (#798)
- Add ArtifactUploadHandler with support for github-artifacts, storage (rclone), and local copy upload targets, including large file chunking for GitHub Artifacts - Add 44 unit tests covering OutputTypeRegistry, OutputService, and ArtifactUploadHandler (config parsing, upload coordination, file collection) - Add 6 new action.yml inputs for artifact configuration - Add artifactManifestPath action output - Wire artifact collection and upload into index.ts post-build flow Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
frostebite
@@ -0,0 +1,522 @@
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { OutputTypeRegistry, OutputTypeDefinition } from './output-type-registry';
|
||||
import { OutputService } from './output-service';
|
||||
import { OutputManifest } from './output-manifest';
|
||||
import { ArtifactUploadHandler, ArtifactUploadConfig } from './artifact-upload-handler';
|
||||
|
||||
// Mock node:fs
|
||||
jest.mock('node:fs');
|
||||
const mockedFs = fs as jest.Mocked<typeof fs>;
|
||||
|
||||
// Mock @actions/core (used by OrchestratorLogger)
|
||||
jest.mock('@actions/core', () => ({
|
||||
info: jest.fn(),
|
||||
warning: jest.fn(),
|
||||
error: jest.fn(),
|
||||
setOutput: jest.fn(),
|
||||
getInput: jest.fn(),
|
||||
setFailed: jest.fn(),
|
||||
setSecret: jest.fn(),
|
||||
}));
|
||||
|
||||
// Mock @actions/exec (used by upload handler for rclone)
|
||||
jest.mock('@actions/exec', () => ({
|
||||
exec: jest.fn().mockResolvedValue(0),
|
||||
}));
|
||||
|
||||
afterEach(() => {
|
||||
jest.restoreAllMocks();
|
||||
OutputTypeRegistry.resetCustomTypes();
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// OutputTypeRegistry Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('OutputTypeRegistry', () => {
|
||||
describe('built-in types', () => {
|
||||
it('should have 8 built-in types', () => {
|
||||
const allTypes = OutputTypeRegistry.getAllTypes();
|
||||
const builtInTypes = allTypes.filter((t) => t.builtIn);
|
||||
expect(builtInTypes).toHaveLength(8);
|
||||
});
|
||||
|
||||
it.each(['build', 'test-results', 'server-build', 'data-export', 'images', 'logs', 'metrics', 'coverage'])(
|
||||
'should include built-in type "%s"',
|
||||
(typeName) => {
|
||||
const typeDef = OutputTypeRegistry.getType(typeName);
|
||||
expect(typeDef).toBeDefined();
|
||||
expect(typeDef!.name).toBe(typeName);
|
||||
expect(typeDef!.builtIn).toBe(true);
|
||||
},
|
||||
);
|
||||
|
||||
it('should return undefined for unknown types', () => {
|
||||
const typeDef = OutputTypeRegistry.getType('nonexistent');
|
||||
expect(typeDef).toBeUndefined();
|
||||
});
|
||||
|
||||
it('should include default paths for all built-in types', () => {
|
||||
const allTypes = OutputTypeRegistry.getAllTypes();
|
||||
for (const typeDef of allTypes) {
|
||||
expect(typeDef.defaultPath).toBeTruthy();
|
||||
expect(typeof typeDef.defaultPath).toBe('string');
|
||||
}
|
||||
});
|
||||
|
||||
it('should include descriptions for all built-in types', () => {
|
||||
const allTypes = OutputTypeRegistry.getAllTypes();
|
||||
for (const typeDef of allTypes) {
|
||||
expect(typeDef.description).toBeTruthy();
|
||||
expect(typeof typeDef.description).toBe('string');
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('custom type registration', () => {
|
||||
it('should register a custom type', () => {
|
||||
const customType: OutputTypeDefinition = {
|
||||
name: 'custom-reports',
|
||||
defaultPath: './Reports/',
|
||||
description: 'Custom generated reports',
|
||||
builtIn: false,
|
||||
};
|
||||
|
||||
OutputTypeRegistry.registerType(customType);
|
||||
const retrieved = OutputTypeRegistry.getType('custom-reports');
|
||||
expect(retrieved).toBeDefined();
|
||||
expect(retrieved!.name).toBe('custom-reports');
|
||||
expect(retrieved!.builtIn).toBe(false);
|
||||
});
|
||||
|
||||
it('should not override built-in types', () => {
|
||||
const override: OutputTypeDefinition = {
|
||||
name: 'build',
|
||||
defaultPath: './Override/',
|
||||
description: 'Should not override',
|
||||
builtIn: false,
|
||||
};
|
||||
|
||||
OutputTypeRegistry.registerType(override);
|
||||
const buildType = OutputTypeRegistry.getType('build');
|
||||
expect(buildType!.defaultPath).not.toBe('./Override/');
|
||||
expect(buildType!.builtIn).toBe(true);
|
||||
});
|
||||
|
||||
it('should include custom types in getAllTypes', () => {
|
||||
OutputTypeRegistry.registerType({
|
||||
name: 'custom-a',
|
||||
defaultPath: './A/',
|
||||
description: 'Custom A',
|
||||
builtIn: false,
|
||||
});
|
||||
|
||||
const allTypes = OutputTypeRegistry.getAllTypes();
|
||||
expect(allTypes.length).toBe(9); // 8 built-in + 1 custom
|
||||
expect(allTypes.some((t) => t.name === 'custom-a')).toBe(true);
|
||||
});
|
||||
|
||||
it('should reset custom types', () => {
|
||||
OutputTypeRegistry.registerType({
|
||||
name: 'temp-type',
|
||||
defaultPath: './Temp/',
|
||||
description: 'Temporary type',
|
||||
builtIn: false,
|
||||
});
|
||||
|
||||
expect(OutputTypeRegistry.getType('temp-type')).toBeDefined();
|
||||
OutputTypeRegistry.resetCustomTypes();
|
||||
expect(OutputTypeRegistry.getType('temp-type')).toBeUndefined();
|
||||
});
|
||||
|
||||
it('should force builtIn to false when registering custom types', () => {
|
||||
OutputTypeRegistry.registerType({
|
||||
name: 'sneaky',
|
||||
defaultPath: './Sneaky/',
|
||||
description: 'Tries to be built-in',
|
||||
builtIn: true, // Intentionally setting to true
|
||||
});
|
||||
|
||||
const retrieved = OutputTypeRegistry.getType('sneaky');
|
||||
expect(retrieved).toBeDefined();
|
||||
expect(retrieved!.builtIn).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('parseOutputTypes', () => {
|
||||
it('should parse a comma-separated string of valid types', () => {
|
||||
const types = OutputTypeRegistry.parseOutputTypes('build,logs,coverage');
|
||||
expect(types).toHaveLength(3);
|
||||
expect(types.map((t) => t.name)).toEqual(['build', 'logs', 'coverage']);
|
||||
});
|
||||
|
||||
it('should skip unknown types', () => {
|
||||
const types = OutputTypeRegistry.parseOutputTypes('build,unknown,logs');
|
||||
expect(types).toHaveLength(2);
|
||||
expect(types.map((t) => t.name)).toEqual(['build', 'logs']);
|
||||
});
|
||||
|
||||
it('should handle empty string', () => {
|
||||
const types = OutputTypeRegistry.parseOutputTypes('');
|
||||
expect(types).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('should handle whitespace in type names', () => {
|
||||
const types = OutputTypeRegistry.parseOutputTypes(' build , logs , coverage ');
|
||||
expect(types).toHaveLength(3);
|
||||
});
|
||||
|
||||
it('should include custom types when parsing', () => {
|
||||
OutputTypeRegistry.registerType({
|
||||
name: 'my-reports',
|
||||
defaultPath: './Reports/',
|
||||
description: 'Custom reports',
|
||||
builtIn: false,
|
||||
});
|
||||
|
||||
const types = OutputTypeRegistry.parseOutputTypes('build,my-reports');
|
||||
expect(types).toHaveLength(2);
|
||||
expect(types[1].name).toBe('my-reports');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// OutputService Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('OutputService', () => {
|
||||
const projectPath = '/project';
|
||||
const buildGuid = 'test-guid-1234';
|
||||
|
||||
beforeEach(() => {
|
||||
// Reset all fs mocks
|
||||
mockedFs.existsSync.mockReset();
|
||||
mockedFs.statSync.mockReset();
|
||||
mockedFs.readdirSync.mockReset();
|
||||
mockedFs.writeFileSync.mockReset();
|
||||
mockedFs.mkdirSync.mockReset();
|
||||
});
|
||||
|
||||
describe('collectOutputs', () => {
|
||||
it('should return an empty manifest when no output types are declared', async () => {
|
||||
const manifest = await OutputService.collectOutputs(projectPath, buildGuid, '');
|
||||
expect(manifest.buildGuid).toBe(buildGuid);
|
||||
expect(manifest.outputs).toHaveLength(0);
|
||||
expect(manifest.timestamp).toBeTruthy();
|
||||
});
|
||||
|
||||
it('should skip outputs where the path does not exist', async () => {
|
||||
mockedFs.existsSync.mockReturnValue(false);
|
||||
|
||||
const manifest = await OutputService.collectOutputs(projectPath, buildGuid, 'build,logs');
|
||||
expect(manifest.outputs).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('should collect directory outputs with file listings', async () => {
|
||||
mockedFs.existsSync.mockReturnValue(true);
|
||||
mockedFs.statSync.mockReturnValue({ isDirectory: () => true, size: 0 } as any);
|
||||
mockedFs.readdirSync.mockImplementation((_dirPath: any, options?: any) => {
|
||||
if (options?.withFileTypes) {
|
||||
return [
|
||||
{ name: 'file1.txt', isDirectory: () => false },
|
||||
{ name: 'file2.txt', isDirectory: () => false },
|
||||
] as any;
|
||||
}
|
||||
|
||||
return ['file1.txt', 'file2.txt'] as any;
|
||||
});
|
||||
|
||||
const manifest = await OutputService.collectOutputs(projectPath, buildGuid, 'logs');
|
||||
expect(manifest.outputs).toHaveLength(1);
|
||||
expect(manifest.outputs[0].type).toBe('logs');
|
||||
expect(manifest.outputs[0].files).toEqual(['file1.txt', 'file2.txt']);
|
||||
});
|
||||
|
||||
it('should collect file output with correct size', async () => {
|
||||
mockedFs.existsSync.mockReturnValue(true);
|
||||
mockedFs.statSync.mockReturnValue({ isDirectory: () => false, size: 4096 } as any);
|
||||
|
||||
const manifest = await OutputService.collectOutputs(projectPath, buildGuid, 'coverage');
|
||||
expect(manifest.outputs).toHaveLength(1);
|
||||
expect(manifest.outputs[0].size).toBe(4096);
|
||||
});
|
||||
|
||||
it('should write manifest to disk when manifestPath is provided', async () => {
|
||||
// existsSync returns false for output paths (no outputs found) but mkdirSync/writeFileSync should still be called
|
||||
// The service only writes manifest when at least one output type is declared and types are resolved
|
||||
// So we need to provide a valid output type and have its path exist
|
||||
mockedFs.existsSync.mockReturnValue(true);
|
||||
mockedFs.statSync.mockReturnValue({ isDirectory: () => false, size: 100 } as any);
|
||||
mockedFs.mkdirSync.mockReturnValue(undefined);
|
||||
mockedFs.writeFileSync.mockImplementation(() => {});
|
||||
|
||||
const manifestPath = '/output/manifest.json';
|
||||
await OutputService.collectOutputs(projectPath, buildGuid, 'logs', manifestPath);
|
||||
|
||||
expect(mockedFs.mkdirSync).toHaveBeenCalledWith(path.dirname(manifestPath), { recursive: true });
|
||||
expect(mockedFs.writeFileSync).toHaveBeenCalledWith(manifestPath, expect.any(String), 'utf8');
|
||||
});
|
||||
|
||||
it('should generate valid JSON in the manifest file', async () => {
|
||||
mockedFs.existsSync.mockReturnValue(true);
|
||||
mockedFs.statSync.mockReturnValue({ isDirectory: () => false, size: 200 } as any);
|
||||
mockedFs.mkdirSync.mockReturnValue(undefined);
|
||||
mockedFs.writeFileSync.mockImplementation(() => {});
|
||||
|
||||
const manifestPath = '/output/manifest.json';
|
||||
await OutputService.collectOutputs(projectPath, buildGuid, 'coverage', manifestPath);
|
||||
|
||||
const writtenContent = (mockedFs.writeFileSync as jest.Mock).mock.calls[0][1];
|
||||
const parsed = JSON.parse(writtenContent);
|
||||
expect(parsed.buildGuid).toBe(buildGuid);
|
||||
expect(Array.isArray(parsed.outputs)).toBe(true);
|
||||
expect(parsed.outputs.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('should set a valid ISO 8601 timestamp', async () => {
|
||||
const manifest = await OutputService.collectOutputs(projectPath, buildGuid, '');
|
||||
const parsed = new Date(manifest.timestamp);
|
||||
expect(parsed.toISOString()).toBe(manifest.timestamp);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// ArtifactUploadHandler Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('ArtifactUploadHandler', () => {
|
||||
const projectPath = '/project';
|
||||
|
||||
beforeEach(() => {
|
||||
mockedFs.existsSync.mockReset();
|
||||
mockedFs.statSync.mockReset();
|
||||
mockedFs.readdirSync.mockReset();
|
||||
mockedFs.mkdirSync.mockReset();
|
||||
mockedFs.copyFileSync.mockReset();
|
||||
});
|
||||
|
||||
describe('parseConfig', () => {
|
||||
it('should parse valid config values', () => {
|
||||
const config = ArtifactUploadHandler.parseConfig('github-artifacts', '/dest', 'gzip', '14');
|
||||
expect(config.target).toBe('github-artifacts');
|
||||
expect(config.destination).toBe('/dest');
|
||||
expect(config.compression).toBe('gzip');
|
||||
expect(config.retentionDays).toBe(14);
|
||||
});
|
||||
|
||||
it('should default invalid target to github-artifacts', () => {
|
||||
const config = ArtifactUploadHandler.parseConfig('invalid', undefined, 'none', '30');
|
||||
expect(config.target).toBe('github-artifacts');
|
||||
});
|
||||
|
||||
it('should default invalid compression to gzip', () => {
|
||||
const config = ArtifactUploadHandler.parseConfig('local', '/dest', 'brotli', '30');
|
||||
expect(config.compression).toBe('gzip');
|
||||
});
|
||||
|
||||
it('should default invalid retention to 30 days', () => {
|
||||
const config = ArtifactUploadHandler.parseConfig('local', '/dest', 'gzip', 'abc');
|
||||
expect(config.retentionDays).toBe(30);
|
||||
});
|
||||
|
||||
it('should default negative retention to 30 days', () => {
|
||||
const config = ArtifactUploadHandler.parseConfig('local', '/dest', 'gzip', '-5');
|
||||
expect(config.retentionDays).toBe(30);
|
||||
});
|
||||
|
||||
it('should set destination to undefined when empty string', () => {
|
||||
const config = ArtifactUploadHandler.parseConfig('storage', '', 'none', '7');
|
||||
expect(config.destination).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('uploadArtifacts', () => {
|
||||
it('should skip upload when target is none', async () => {
|
||||
const manifest: OutputManifest = {
|
||||
buildGuid: 'test-guid',
|
||||
timestamp: new Date().toISOString(),
|
||||
outputs: [{ type: 'build', path: './Builds/' }],
|
||||
};
|
||||
|
||||
const config: ArtifactUploadConfig = {
|
||||
target: 'none',
|
||||
compression: 'gzip',
|
||||
retentionDays: 30,
|
||||
};
|
||||
|
||||
const result = await ArtifactUploadHandler.uploadArtifacts(manifest, config, projectPath);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.entries).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('should return success with no entries for empty manifest', async () => {
|
||||
const manifest: OutputManifest = {
|
||||
buildGuid: 'test-guid',
|
||||
timestamp: new Date().toISOString(),
|
||||
outputs: [],
|
||||
};
|
||||
|
||||
const config: ArtifactUploadConfig = {
|
||||
target: 'github-artifacts',
|
||||
compression: 'gzip',
|
||||
retentionDays: 30,
|
||||
};
|
||||
|
||||
const result = await ArtifactUploadHandler.uploadArtifacts(manifest, config, projectPath);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.entries).toHaveLength(0);
|
||||
expect(result.totalBytes).toBe(0);
|
||||
});
|
||||
|
||||
it('should fail entry when output path does not exist', async () => {
|
||||
mockedFs.existsSync.mockReturnValue(false);
|
||||
|
||||
const manifest: OutputManifest = {
|
||||
buildGuid: 'test-guid',
|
||||
timestamp: new Date().toISOString(),
|
||||
outputs: [{ type: 'build', path: './Builds/Missing/' }],
|
||||
};
|
||||
|
||||
const config: ArtifactUploadConfig = {
|
||||
target: 'local',
|
||||
destination: '/output',
|
||||
compression: 'none',
|
||||
retentionDays: 30,
|
||||
};
|
||||
|
||||
const result = await ArtifactUploadHandler.uploadArtifacts(manifest, config, projectPath);
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.entries).toHaveLength(1);
|
||||
expect(result.entries[0].success).toBe(false);
|
||||
expect(result.entries[0].error).toContain('does not exist');
|
||||
});
|
||||
|
||||
it('should copy files for local upload target', async () => {
|
||||
mockedFs.existsSync.mockReturnValue(true);
|
||||
mockedFs.statSync.mockReturnValue({ isDirectory: () => false, size: 1024 } as any);
|
||||
mockedFs.mkdirSync.mockReturnValue(undefined);
|
||||
mockedFs.copyFileSync.mockReturnValue(undefined);
|
||||
|
||||
const manifest: OutputManifest = {
|
||||
buildGuid: 'test-guid',
|
||||
timestamp: new Date().toISOString(),
|
||||
outputs: [{ type: 'logs', path: './Logs/build.log', size: 1024 }],
|
||||
};
|
||||
|
||||
const config: ArtifactUploadConfig = {
|
||||
target: 'local',
|
||||
destination: '/output',
|
||||
compression: 'none',
|
||||
retentionDays: 30,
|
||||
};
|
||||
|
||||
const result = await ArtifactUploadHandler.uploadArtifacts(manifest, config, projectPath);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.entries).toHaveLength(1);
|
||||
expect(result.entries[0].success).toBe(true);
|
||||
expect(result.totalBytes).toBe(1024);
|
||||
});
|
||||
|
||||
it('should fail local upload when no destination is provided', async () => {
|
||||
mockedFs.existsSync.mockReturnValue(true);
|
||||
mockedFs.statSync.mockReturnValue({ isDirectory: () => false, size: 512 } as any);
|
||||
|
||||
const manifest: OutputManifest = {
|
||||
buildGuid: 'test-guid',
|
||||
timestamp: new Date().toISOString(),
|
||||
outputs: [{ type: 'logs', path: './Logs/build.log', size: 512 }],
|
||||
};
|
||||
|
||||
const config: ArtifactUploadConfig = {
|
||||
target: 'local',
|
||||
compression: 'none',
|
||||
retentionDays: 30,
|
||||
};
|
||||
|
||||
const result = await ArtifactUploadHandler.uploadArtifacts(manifest, config, projectPath);
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.entries[0].success).toBe(false);
|
||||
expect(result.entries[0].error).toContain('destination path');
|
||||
});
|
||||
|
||||
it('should report correct duration', async () => {
|
||||
const manifest: OutputManifest = {
|
||||
buildGuid: 'test-guid',
|
||||
timestamp: new Date().toISOString(),
|
||||
outputs: [],
|
||||
};
|
||||
|
||||
const config: ArtifactUploadConfig = {
|
||||
target: 'none',
|
||||
compression: 'gzip',
|
||||
retentionDays: 30,
|
||||
};
|
||||
|
||||
const result = await ArtifactUploadHandler.uploadArtifacts(manifest, config, projectPath);
|
||||
expect(result.durationMs).toBeGreaterThanOrEqual(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('collectFiles', () => {
|
||||
it('should return single file for a file path', () => {
|
||||
mockedFs.statSync.mockReturnValue({ isDirectory: () => false } as any);
|
||||
|
||||
const files = ArtifactUploadHandler.collectFiles('/path/to/file.txt');
|
||||
expect(files).toEqual(['/path/to/file.txt']);
|
||||
});
|
||||
|
||||
it('should return all files recursively for a directory', () => {
|
||||
mockedFs.statSync.mockImplementation((p: any) => {
|
||||
const pathStr = typeof p === 'string' ? p : p.toString();
|
||||
if (pathStr.endsWith('.txt') || pathStr.endsWith('.log')) {
|
||||
return { isDirectory: () => false } as any;
|
||||
}
|
||||
|
||||
return { isDirectory: () => true } as any;
|
||||
});
|
||||
|
||||
mockedFs.readdirSync.mockImplementation((dirPath: any, _options?: any) => {
|
||||
const dirStr = typeof dirPath === 'string' ? dirPath : dirPath.toString();
|
||||
if (dirStr === '/root') {
|
||||
return [
|
||||
{ name: 'file1.txt', isDirectory: () => false },
|
||||
{ name: 'sub', isDirectory: () => true },
|
||||
] as any;
|
||||
}
|
||||
if (dirStr.endsWith('sub')) {
|
||||
return [{ name: 'file2.log', isDirectory: () => false }] as any;
|
||||
}
|
||||
|
||||
return [] as any;
|
||||
});
|
||||
|
||||
const files = ArtifactUploadHandler.collectFiles('/root');
|
||||
expect(files).toHaveLength(2);
|
||||
expect(files).toContain(path.join('/root', 'file1.txt'));
|
||||
expect(files).toContain(path.join('/root', 'sub', 'file2.log'));
|
||||
});
|
||||
});
|
||||
|
||||
describe('storage upload validation', () => {
|
||||
it('should fail storage upload when no destination is provided', async () => {
|
||||
mockedFs.existsSync.mockReturnValue(true);
|
||||
mockedFs.statSync.mockReturnValue({ isDirectory: () => false, size: 256 } as any);
|
||||
|
||||
const manifest: OutputManifest = {
|
||||
buildGuid: 'test-guid',
|
||||
timestamp: new Date().toISOString(),
|
||||
outputs: [{ type: 'build', path: './Builds/', size: 256 }],
|
||||
};
|
||||
|
||||
const config: ArtifactUploadConfig = {
|
||||
target: 'storage',
|
||||
compression: 'gzip',
|
||||
retentionDays: 30,
|
||||
};
|
||||
|
||||
const result = await ArtifactUploadHandler.uploadArtifacts(manifest, config, projectPath);
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.entries[0].error).toContain('destination URI');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,414 @@
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { exec } from '@actions/exec';
|
||||
import OrchestratorLogger from '../core/orchestrator-logger';
|
||||
import { OutputManifest, OutputEntry } from './output-manifest';
|
||||
|
||||
/**
|
||||
* Configuration for artifact upload.
|
||||
*/
|
||||
export interface ArtifactUploadConfig {
|
||||
/** Upload target: 'github-artifacts', 'storage', 'local', 'none' */
|
||||
target: 'github-artifacts' | 'storage' | 'local' | 'none';
|
||||
|
||||
/** Destination path — storage URI for 'storage', local path for 'local' */
|
||||
destination?: string;
|
||||
|
||||
/** Compression method */
|
||||
compression: 'none' | 'gzip' | 'lz4';
|
||||
|
||||
/** Retention period in days (GitHub Artifacts only) */
|
||||
retentionDays: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Result of an artifact upload operation.
|
||||
*/
|
||||
export interface UploadResult {
|
||||
/** Whether the upload succeeded overall */
|
||||
success: boolean;
|
||||
|
||||
/** Per-entry upload results */
|
||||
entries: UploadEntryResult[];
|
||||
|
||||
/** Total bytes uploaded */
|
||||
totalBytes: number;
|
||||
|
||||
/** Duration in milliseconds */
|
||||
durationMs: number;
|
||||
}
|
||||
|
||||
export interface UploadEntryResult {
|
||||
/** The output type name */
|
||||
type: string;
|
||||
|
||||
/** The output path */
|
||||
path: string;
|
||||
|
||||
/** Whether this entry uploaded successfully */
|
||||
success: boolean;
|
||||
|
||||
/** Bytes uploaded for this entry */
|
||||
bytes: number;
|
||||
|
||||
/** Error message if upload failed */
|
||||
error?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* GitHub Artifacts size limit per artifact (10 GB).
|
||||
* Files larger than this must be split.
|
||||
*/
|
||||
const GITHUB_ARTIFACT_SIZE_LIMIT = 10 * 1024 * 1024 * 1024;
|
||||
|
||||
/**
|
||||
* Handles uploading build artifacts to various targets.
|
||||
*/
|
||||
export class ArtifactUploadHandler {
|
||||
/**
|
||||
* Upload artifacts described by a manifest to the configured target.
|
||||
*/
|
||||
static async uploadArtifacts(
|
||||
manifest: OutputManifest,
|
||||
config: ArtifactUploadConfig,
|
||||
projectPath: string,
|
||||
): Promise<UploadResult> {
|
||||
const startTime = Date.now();
|
||||
const result: UploadResult = {
|
||||
success: true,
|
||||
entries: [],
|
||||
totalBytes: 0,
|
||||
durationMs: 0,
|
||||
};
|
||||
|
||||
if (config.target === 'none') {
|
||||
OrchestratorLogger.log('[ArtifactUpload] Upload target is "none", skipping upload');
|
||||
result.durationMs = Date.now() - startTime;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
if (manifest.outputs.length === 0) {
|
||||
OrchestratorLogger.log('[ArtifactUpload] No outputs in manifest, nothing to upload');
|
||||
result.durationMs = Date.now() - startTime;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
OrchestratorLogger.log(`[ArtifactUpload] Uploading ${manifest.outputs.length} output(s) to ${config.target}`);
|
||||
|
||||
for (const entry of manifest.outputs) {
|
||||
const entryResult = await ArtifactUploadHandler.uploadEntry(entry, config, projectPath);
|
||||
result.entries.push(entryResult);
|
||||
result.totalBytes += entryResult.bytes;
|
||||
|
||||
if (!entryResult.success) {
|
||||
result.success = false;
|
||||
}
|
||||
}
|
||||
|
||||
result.durationMs = Date.now() - startTime;
|
||||
|
||||
OrchestratorLogger.log(
|
||||
`[ArtifactUpload] Upload complete: ${result.entries.filter((e) => e.success).length}/${
|
||||
result.entries.length
|
||||
} succeeded, ${result.totalBytes} bytes, ${result.durationMs}ms`,
|
||||
);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Upload a single output entry.
|
||||
*/
|
||||
private static async uploadEntry(
|
||||
entry: OutputEntry,
|
||||
config: ArtifactUploadConfig,
|
||||
projectPath: string,
|
||||
): Promise<UploadEntryResult> {
|
||||
const entryResult: UploadEntryResult = {
|
||||
type: entry.type,
|
||||
path: entry.path,
|
||||
success: false,
|
||||
bytes: entry.size || 0,
|
||||
};
|
||||
|
||||
const resolvedPath = path.resolve(
|
||||
projectPath,
|
||||
entry.path.replace('{platform}', process.env.BUILD_TARGET || 'Unknown'),
|
||||
);
|
||||
|
||||
if (!fs.existsSync(resolvedPath)) {
|
||||
entryResult.error = `Output path does not exist: ${resolvedPath}`;
|
||||
OrchestratorLogger.logWarning(`[ArtifactUpload] ${entryResult.error}`);
|
||||
|
||||
return entryResult;
|
||||
}
|
||||
|
||||
try {
|
||||
switch (config.target) {
|
||||
case 'github-artifacts':
|
||||
await ArtifactUploadHandler.uploadToGitHubArtifacts(entry, resolvedPath, config);
|
||||
break;
|
||||
case 'storage':
|
||||
await ArtifactUploadHandler.uploadToStorage(entry, resolvedPath, config);
|
||||
break;
|
||||
case 'local':
|
||||
await ArtifactUploadHandler.uploadToLocal(entry, resolvedPath, config);
|
||||
break;
|
||||
}
|
||||
entryResult.success = true;
|
||||
OrchestratorLogger.log(
|
||||
`[ArtifactUpload] Uploaded '${entry.type}' (${entryResult.bytes} bytes) to ${config.target}`,
|
||||
);
|
||||
} catch (error: any) {
|
||||
entryResult.error = error.message || String(error);
|
||||
OrchestratorLogger.logWarning(`[ArtifactUpload] Failed to upload '${entry.type}': ${entryResult.error}`);
|
||||
}
|
||||
|
||||
return entryResult;
|
||||
}
|
||||
|
||||
/**
|
||||
* Upload to GitHub Artifacts via @actions/artifact.
|
||||
* Handles large file splitting if artifacts exceed the size limit.
|
||||
*/
|
||||
private static async uploadToGitHubArtifacts(
|
||||
entry: OutputEntry,
|
||||
resolvedPath: string,
|
||||
config: ArtifactUploadConfig,
|
||||
): Promise<void> {
|
||||
// Dynamically require @actions/artifact — it may not be available in all environments.
|
||||
// Using a variable to prevent TypeScript from resolving the module at compile time.
|
||||
let artifact: any;
|
||||
try {
|
||||
const artifactModule = '@actions/artifact';
|
||||
// eslint-disable-next-line @typescript-eslint/no-require-imports
|
||||
artifact = require(artifactModule);
|
||||
} catch {
|
||||
throw new Error('@actions/artifact package is not available. Install it to use github-artifacts upload target.');
|
||||
}
|
||||
|
||||
const artifactClient = artifact.DefaultArtifactClient
|
||||
? new artifact.DefaultArtifactClient()
|
||||
: artifact.default
|
||||
? new artifact.default()
|
||||
: artifact;
|
||||
|
||||
const files = ArtifactUploadHandler.collectFiles(resolvedPath);
|
||||
|
||||
if (files.length === 0) {
|
||||
OrchestratorLogger.logWarning(`[ArtifactUpload] No files found at ${resolvedPath} for '${entry.type}'`);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
const totalSize = entry.size || 0;
|
||||
const artifactName = `unity-output-${entry.type}`;
|
||||
|
||||
if (totalSize > GITHUB_ARTIFACT_SIZE_LIMIT) {
|
||||
OrchestratorLogger.log(
|
||||
`[ArtifactUpload] Output '${entry.type}' exceeds GitHub Artifacts size limit (${totalSize} > ${GITHUB_ARTIFACT_SIZE_LIMIT}), splitting into chunks`,
|
||||
);
|
||||
await ArtifactUploadHandler.uploadChunked(artifactClient, artifactName, files, resolvedPath, config);
|
||||
} else {
|
||||
const rootDirectory = fs.statSync(resolvedPath).isDirectory() ? resolvedPath : path.dirname(resolvedPath);
|
||||
|
||||
if (typeof artifactClient.uploadArtifact === 'function') {
|
||||
await artifactClient.uploadArtifact(artifactName, files, rootDirectory, {
|
||||
retentionDays: config.retentionDays,
|
||||
compressionLevel: config.compression === 'none' ? 0 : 6,
|
||||
});
|
||||
} else {
|
||||
throw new Error(
|
||||
'@actions/artifact client does not have uploadArtifact method. Ensure the package version is compatible.',
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Upload large artifacts in chunks to stay within GitHub size limits.
|
||||
*/
|
||||
private static async uploadChunked(
|
||||
artifactClient: any,
|
||||
baseName: string,
|
||||
files: string[],
|
||||
rootDirectory: string,
|
||||
config: ArtifactUploadConfig,
|
||||
): Promise<void> {
|
||||
const chunkSize = GITHUB_ARTIFACT_SIZE_LIMIT;
|
||||
let currentChunkFiles: string[] = [];
|
||||
let currentChunkSize = 0;
|
||||
let chunkIndex = 0;
|
||||
|
||||
for (const filePath of files) {
|
||||
const fileSize = fs.statSync(filePath).size;
|
||||
|
||||
if (currentChunkSize + fileSize > chunkSize && currentChunkFiles.length > 0) {
|
||||
await ArtifactUploadHandler.uploadSingleChunk(
|
||||
artifactClient,
|
||||
`${baseName}-part${chunkIndex}`,
|
||||
currentChunkFiles,
|
||||
rootDirectory,
|
||||
config,
|
||||
);
|
||||
chunkIndex++;
|
||||
currentChunkFiles = [];
|
||||
currentChunkSize = 0;
|
||||
}
|
||||
|
||||
currentChunkFiles.push(filePath);
|
||||
currentChunkSize += fileSize;
|
||||
}
|
||||
|
||||
if (currentChunkFiles.length > 0) {
|
||||
await ArtifactUploadHandler.uploadSingleChunk(
|
||||
artifactClient,
|
||||
chunkIndex > 0 ? `${baseName}-part${chunkIndex}` : baseName,
|
||||
currentChunkFiles,
|
||||
rootDirectory,
|
||||
config,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
private static async uploadSingleChunk(
|
||||
artifactClient: any,
|
||||
name: string,
|
||||
files: string[],
|
||||
rootDirectory: string,
|
||||
config: ArtifactUploadConfig,
|
||||
): Promise<void> {
|
||||
OrchestratorLogger.log(`[ArtifactUpload] Uploading chunk '${name}' with ${files.length} file(s)`);
|
||||
|
||||
if (typeof artifactClient.uploadArtifact === 'function') {
|
||||
await artifactClient.uploadArtifact(name, files, rootDirectory, {
|
||||
retentionDays: config.retentionDays,
|
||||
compressionLevel: config.compression === 'none' ? 0 : 6,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Upload to remote storage via rclone.
|
||||
*/
|
||||
private static async uploadToStorage(
|
||||
entry: OutputEntry,
|
||||
resolvedPath: string,
|
||||
config: ArtifactUploadConfig,
|
||||
): Promise<void> {
|
||||
if (!config.destination) {
|
||||
throw new Error('Storage upload requires a destination URI in artifactUploadPath');
|
||||
}
|
||||
|
||||
const destination = `${config.destination}/${entry.type}`;
|
||||
|
||||
OrchestratorLogger.log(`[ArtifactUpload] Uploading '${entry.type}' to storage: ${destination}`);
|
||||
|
||||
const args = ['copy', resolvedPath, destination, '--progress'];
|
||||
|
||||
if (config.compression !== 'none') {
|
||||
// rclone doesn't have built-in compression flags for copy;
|
||||
// compression is typically handled by the remote configuration.
|
||||
// Log as informational.
|
||||
OrchestratorLogger.log(
|
||||
`[ArtifactUpload] Note: compression '${config.compression}' is configured at the remote level for rclone`,
|
||||
);
|
||||
}
|
||||
|
||||
await exec('rclone', args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Upload to a local path (copy).
|
||||
*/
|
||||
private static async uploadToLocal(
|
||||
entry: OutputEntry,
|
||||
resolvedPath: string,
|
||||
config: ArtifactUploadConfig,
|
||||
): Promise<void> {
|
||||
if (!config.destination) {
|
||||
throw new Error('Local upload requires a destination path in artifactUploadPath');
|
||||
}
|
||||
|
||||
const destination = path.join(config.destination, entry.type);
|
||||
fs.mkdirSync(destination, { recursive: true });
|
||||
|
||||
OrchestratorLogger.log(`[ArtifactUpload] Copying '${entry.type}' to local path: ${destination}`);
|
||||
|
||||
ArtifactUploadHandler.copyRecursive(resolvedPath, destination);
|
||||
}
|
||||
|
||||
/**
|
||||
* Recursively copy files from source to destination.
|
||||
*/
|
||||
private static copyRecursive(source: string, destination: string): void {
|
||||
const stat = fs.statSync(source);
|
||||
|
||||
if (stat.isDirectory()) {
|
||||
fs.mkdirSync(destination, { recursive: true });
|
||||
const entries = fs.readdirSync(source);
|
||||
for (const entry of entries) {
|
||||
ArtifactUploadHandler.copyRecursive(path.join(source, entry), path.join(destination, entry));
|
||||
}
|
||||
} else {
|
||||
fs.copyFileSync(source, destination);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Collect all files at a given path (recursively if directory).
|
||||
*/
|
||||
static collectFiles(targetPath: string): string[] {
|
||||
const stat = fs.statSync(targetPath);
|
||||
|
||||
if (!stat.isDirectory()) {
|
||||
return [targetPath];
|
||||
}
|
||||
|
||||
const files: string[] = [];
|
||||
const entries = fs.readdirSync(targetPath, { withFileTypes: true });
|
||||
|
||||
for (const entry of entries) {
|
||||
const fullPath = path.join(targetPath, entry.name);
|
||||
if (entry.isDirectory()) {
|
||||
files.push(...ArtifactUploadHandler.collectFiles(fullPath));
|
||||
} else {
|
||||
files.push(fullPath);
|
||||
}
|
||||
}
|
||||
|
||||
return files;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse an ArtifactUploadConfig from action inputs.
|
||||
*/
|
||||
static parseConfig(
|
||||
target: string,
|
||||
destination: string | undefined,
|
||||
compression: string,
|
||||
retentionDays: string,
|
||||
): ArtifactUploadConfig {
|
||||
const validTargets = ['github-artifacts', 'storage', 'local', 'none'] as const;
|
||||
const resolvedTarget = validTargets.includes(target as any)
|
||||
? (target as ArtifactUploadConfig['target'])
|
||||
: 'github-artifacts';
|
||||
|
||||
const validCompressions = ['none', 'gzip', 'lz4'] as const;
|
||||
const resolvedCompression = validCompressions.includes(compression as any)
|
||||
? (compression as ArtifactUploadConfig['compression'])
|
||||
: 'gzip';
|
||||
|
||||
const parsedRetention = Number.parseInt(retentionDays, 10);
|
||||
const resolvedRetention = Number.isNaN(parsedRetention) || parsedRetention <= 0 ? 30 : parsedRetention;
|
||||
|
||||
return {
|
||||
target: resolvedTarget,
|
||||
destination: destination || undefined,
|
||||
compression: resolvedCompression,
|
||||
retentionDays: resolvedRetention,
|
||||
};
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user