Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
commit
c652a5276d
1192 files changed
+272368
No files matched your search
@@ -0,0 +1,286 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
#if VCC_UI_TESTING
|
||||
import Foundation
|
||||
import CryptoKit
|
||||
|
||||
// Authored transport + catalog for native install checks. Compiled only into the
|
||||
// isolated UI-test app. Every request is intercepted, including unknown URLs,
|
||||
// so the fixture cannot accidentally reach the production download service.
|
||||
enum SoftwareLibraryInstallFixture {
|
||||
static var enabled: Bool { CommandLine.arguments.contains("--library-install-fixture") || playEnabled || exclusiveEnabled }
|
||||
static var playEnabled: Bool { CommandLine.arguments.contains("--library-play-fixture") }
|
||||
static var exclusiveEnabled: Bool { CommandLine.arguments.contains("--library-exclusive-fixture") }
|
||||
static var sourceConfiguration: URLSessionConfiguration { sessionConfiguration() }
|
||||
static let titleID = "authored-library-title"
|
||||
static let releaseID = "authored-library-cartridge"
|
||||
static let downloadURL = URL(string: "https://vccplus.brianholman.com/dl/software/CoCoLibrary/Cartridges/Authored%20Library%20Cartridge.ccc")!
|
||||
static let bytes: Data = {
|
||||
var value = Data(repeating: 0x12, count: 8192)
|
||||
value[0] = 0x20; value[1] = 0xfe
|
||||
return value
|
||||
}()
|
||||
static let digest = SHA256.hash(data: bytes).map { String(format: "%02x", $0) }.joined()
|
||||
static var catalog: SoftwareLibraryCatalog {
|
||||
if exclusiveEnabled { return exclusiveCatalog }
|
||||
if playEnabled { return playCatalog }
|
||||
let setup = SoftwareLibrarySetup(status: "inferred-ready", command: nil,
|
||||
instructions: "Authored UI-test cartridge. Installation does not attach or run it.",
|
||||
configuration: .object(["profile": .string("disk-basic"), "processor": .string("6809"), "ram_kib": .number(512)]),
|
||||
selectedMembers: .array([]), reasons: [], validation: .object([:]))
|
||||
let release = SoftwareLibraryRelease(id: releaseID, titleID: titleID,
|
||||
name: "Authored Library Cartridge.ccc", category: "Cartridges", mediaType: "cartridge", contentRole: "software",
|
||||
sourceURL: URL(string: "https://example.invalid/Authored%20Library%20Cartridge.ccc")!,
|
||||
modifiedAt: nil, modifiedPrecision: nil, modifiedTimezone: nil,
|
||||
packageSHA256: digest, byteSize: Int64(bytes.count), languageStatus: "english",
|
||||
metadata: .object(["system": .string("coco3"), "publisher": .string("VCC Plus test fixture")]),
|
||||
setup: setup, assets: [], downloadURLs: [downloadURL])
|
||||
return SoftwareLibraryCatalog(titles: [SoftwareLibraryTitle(id: titleID,
|
||||
name: "Authored Library Cartridge", identityStatus: "confirmed", releases: [release])],
|
||||
metadata: ["schema_version": "1", "recipe_contract": "2", "stage": "authored-ui-fixture",
|
||||
"archive_attribution": "Authored test content; no Archive software is used."])
|
||||
}
|
||||
static let manualReleaseID = "authored-library-manual-disk"
|
||||
static let missingReleaseID = "authored-library-missing-member"
|
||||
static let diskBytes = Data(repeating: 0, count: 161280)
|
||||
private static func playRelease(id: String, name: String, media: String, data: Data, missing: Bool = false) -> SoftwareLibraryRelease {
|
||||
let filename = name + (media == "cartridge" ? ".ccc" : ".dsk")
|
||||
let source = URL(string: "https://example.invalid/")!.appendingPathComponent(filename)
|
||||
let download = URL(string: "https://vccplus.brianholman.com/dl/software/CoCoLibrary/Fixtures/")!.appendingPathComponent(filename)
|
||||
let hash = SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
|
||||
let cartridge = media == "cartridge"
|
||||
var configuration: [String: LibraryJSON] = [
|
||||
"profile": .string(cartridge ? "rom-cartridge" : "disk-basic"),
|
||||
"processor": .string("6809"), "ram_kib": .number(2048), "video": .string("composite"),
|
||||
"controller_slot": .number(4), "cartridge_slot": .number(4),
|
||||
"floppy_controller_enabled": .bool(!cartridge), "controls": .object([:])
|
||||
]
|
||||
if cartridge { configuration["launch_method"] = .string("cartridge-autostart") }
|
||||
let setup = SoftwareLibrarySetup(status: cartridge ? "inferred-ready" : "manual-setup", command: nil,
|
||||
instructions: cartridge ? "Authored cartridge: verifies setup and resume without a private ROM." : "Authored blank disk: mount it and use the BASIC prompt manually. No loading command is supplied.",
|
||||
configuration: .object(configuration),
|
||||
selectedMembers: .array([.object(["path": .string(missing ? "Missing.ccc" : filename),
|
||||
"target": .string(cartridge ? "cartridge" : "disk0"),
|
||||
"sha256": .string(hash), "byte_size": .number(Double(data.count))])]),
|
||||
reasons: [], validation: .object([:]))
|
||||
return SoftwareLibraryRelease(id: id, titleID: id, name: filename,
|
||||
category: cartridge ? "Cartridges" : "Disks/Blank disks", mediaType: media, contentRole: "software",
|
||||
sourceURL: source, modifiedAt: nil, modifiedPrecision: nil, modifiedTimezone: nil,
|
||||
packageSHA256: hash, byteSize: Int64(data.count), languageStatus: "english",
|
||||
metadata: .object(["system": .string("CoCo 3"), "publisher": .string("VCC Plus test fixture")]),
|
||||
setup: setup, assets: [], downloadURLs: [download])
|
||||
}
|
||||
static var playCatalog: SoftwareLibraryCatalog {
|
||||
let releases = [
|
||||
playRelease(id: releaseID, name: "Authored Library Cartridge", media: "cartridge", data: bytes),
|
||||
playRelease(id: manualReleaseID, name: "Authored Manual Disk", media: "disk", data: diskBytes),
|
||||
playRelease(id: missingReleaseID, name: "Missing Media Reference", media: "cartridge", data: bytes, missing: true)
|
||||
]
|
||||
return SoftwareLibraryCatalog(titles: releases.map {
|
||||
SoftwareLibraryTitle(id: $0.titleID, name: $0.sourceURL.deletingPathExtension().lastPathComponent,
|
||||
identityStatus: "confirmed", releases: [$0])
|
||||
}, metadata: ["schema_version": "1", "recipe_contract": "2", "stage": "authored-ui-fixture"])
|
||||
}
|
||||
static func playData(for url: URL?) -> Data? {
|
||||
guard let release = playCatalog.releases.first(where: { $0.downloadURLs.first == url }) else { return nil }
|
||||
return release.mediaType == "disk" ? diskBytes : bytes
|
||||
}
|
||||
static func installer(root: URL) -> SoftwareLibraryInstaller {
|
||||
SoftwareLibraryInstaller(root: root, session: URLSession(configuration: sessionConfiguration()))
|
||||
}
|
||||
static func sessionConfiguration() -> URLSessionConfiguration {
|
||||
let configuration = URLSessionConfiguration.ephemeral
|
||||
configuration.protocolClasses = [LibraryFixtureURLProtocol.self]
|
||||
configuration.urlCache = nil
|
||||
configuration.requestCachePolicy = .reloadIgnoringLocalCacheData
|
||||
return configuration
|
||||
}
|
||||
|
||||
static let exclusiveTitleID = "vccplus.fixture-orbit"
|
||||
static let exclusiveReleaseID = "vccplus.fixture-orbit.1"
|
||||
static let exclusiveBase = "https://vccplus.brianholman.com/dl/software/CoCoLibrary/"
|
||||
static let exclusiveSourceURL = URL(string: exclusiveBase + "Sources/Exclusives/FixtureOrbit/1/FixtureOrbit-Source.zip")!
|
||||
static let exclusiveDiskURL = URL(string: exclusiveBase + "Exclusives/FixtureOrbit/1/FixtureOrbit.zip")!
|
||||
static let exclusiveManualURL = URL(string: exclusiveBase + "Documents/Manuals/Exclusives/FixtureOrbit/1/Manual.pdf")!
|
||||
static let exclusiveArtworkURL = URL(string: exclusiveBase + "Artwork/Thumbnails/Exclusives/FixtureOrbit/1/Cover.png")!
|
||||
static let exclusiveArtwork = Data(base64Encoded: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=")!
|
||||
static func checksum(_ data: Data) -> String { SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined() }
|
||||
static let exclusiveSourceBytes = storedZIP([
|
||||
("FixtureOrbit/main.c", Data("/* Authored exclusive-title UI fixture. */\nint fixture_orbit;\nint main(void) { return 0; }\n".utf8)),
|
||||
("FixtureOrbit/Makefile", Data("UI_SENTINEL := $(shell touch MAKE_WAS_RUN)\nbuild:\n\ttouch MAKE_WAS_RUN\n".utf8)),
|
||||
("FixtureOrbit/vccplus-project.json", Data("{\"entrySource\":\"main.c\",\"makefile\":\"Makefile\",\"binary\":\"main.bin\"}".utf8)),
|
||||
("FixtureOrbit/LICENSE", Data("CC0-1.0: authored VCC Plus test fixture only.\n".utf8))
|
||||
])
|
||||
static let exclusiveDiskPackage = storedZIP([("ORBIT.DSK", diskBytes)])
|
||||
static let exclusiveManual: Data = {
|
||||
let stream = "BT /F1 18 Tf 30 170 Td (Fixture Orbit Manual) Tj 0 -30 Td /F1 11 Tf (Authored offline UI-test documentation.) Tj ET\n"
|
||||
let objects = ["<< /Type /Catalog /Pages 2 0 R >>", "<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
|
||||
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 320 220] /Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R >>",
|
||||
"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>", "<< /Length \(stream.utf8.count) >>\nstream\n\(stream)endstream"]
|
||||
var output = "%PDF-1.4\n", offsets = [0]
|
||||
for (index, object) in objects.enumerated() {
|
||||
offsets.append(output.utf8.count); output += "\(index + 1) 0 obj\n\(object)\nendobj\n"
|
||||
}
|
||||
let xref = output.utf8.count
|
||||
output += "xref\n0 \(objects.count + 1)\n0000000000 65535 f \n"
|
||||
for offset in offsets.dropFirst() { output += String(format: "%010d 00000 n \n", offset) }
|
||||
output += "trailer\n<< /Size \(objects.count + 1) /Root 1 0 R >>\nstartxref\n\(xref)\n%%EOF\n"
|
||||
return Data(output.utf8)
|
||||
}()
|
||||
private static func exclusiveFile(_ url: URL, _ data: Data) -> LibraryJSON {
|
||||
.object(["url": .string(url.absoluteString), "sha256": .string(checksum(data)), "byte_size": .number(Double(data.count))])
|
||||
}
|
||||
static var exclusiveCatalog: SoftwareLibraryCatalog {
|
||||
let diskSHA = checksum(diskBytes)
|
||||
let configuration: LibraryJSON = .object(["profile": .string("disk-basic"), "processor": .string("6809"),
|
||||
"ram_kib": .number(128), "video": .string("rgb"), "controller_slot": .number(4)])
|
||||
let selected: LibraryJSON = .array([.object(["path": .string("ORBIT.DSK"), "target": .string("disk0")])])
|
||||
let validation: LibraryJSON = .object(["scope": .string("runtime-verified"), "disk_sha256": .string(diskSHA)])
|
||||
let owned: LibraryJSON = .object([
|
||||
"schema_version": .number(1), "id": .string(exclusiveTitleID), "release_id": .string(exclusiveReleaseID),
|
||||
"publication_status": .string("approved"), "getting_started": .bool(true), "category_featured": .bool(true),
|
||||
"browse_categories": .array([.string("Educational"), .string("Games")]), "primary_browse_category": .string("Educational"),
|
||||
"provenance": .object(["kind": .string("project-owned"), "collection": .string("vccplus-exclusive"),
|
||||
"author": .string("Fixture Author"), "license": .string("CC0-1.0 authored fixture"), "project_url": .string("https://example.invalid/fixture-orbit/")]),
|
||||
"disk_package": exclusiveFile(exclusiveDiskURL, exclusiveDiskPackage),
|
||||
"disk": .object(["path": .string("ORBIT.DSK"), "sha256": .string(diskSHA), "byte_size": .number(Double(diskBytes.count))]),
|
||||
"setup": .object(["configuration": configuration, "selected_members": selected, "command": .string("DOS\r"), "validation": validation]),
|
||||
"first_play": .object(["mode": .string("cold-restart-dos")]),
|
||||
"links": .object(["manual_online": .string("https://vccplus.brianholman.com/games/fixture-orbit/"),
|
||||
"manual_pdf": exclusiveFile(exclusiveManualURL, exclusiveManual), "source_repository": .string("https://example.invalid/FixtureOrbit")]),
|
||||
"source": .object(["package": exclusiveFile(exclusiveSourceURL, exclusiveSourceBytes),
|
||||
"project_directory": .string("FixtureOrbit"), "configuration_file": .string("FixtureOrbit/vccplus-project.json"),
|
||||
"entry_source": .string("main.c"), "license_files": .array([.string("FixtureOrbit/LICENSE")]),
|
||||
"build_configuration": .string("Release")])
|
||||
])
|
||||
var art = SoftwareLibraryAsset(id: "fixture-orbit-cover", name: "Authored fixture cover", kind: "screenshot",
|
||||
sourceURL: URL(string: "https://example.invalid/fixture-orbit/")!, sha256: checksum(exclusiveArtwork),
|
||||
byteSize: Int64(exclusiveArtwork.count), credit: "Authored test fixture", matchStatus: "confirmed", matchReason: "Authored fixture")
|
||||
art.thumbnailURL = exclusiveArtworkURL; art.thumbnailSHA256 = checksum(exclusiveArtwork); art.thumbnailByteSize = Int64(exclusiveArtwork.count)
|
||||
let release = SoftwareLibraryRelease(id: exclusiveReleaseID, titleID: exclusiveTitleID, name: "FixtureOrbit.zip",
|
||||
category: "Disks/Educational", mediaType: "disk", contentRole: "software", sourceURL: URL(string: "https://example.invalid/fixture-orbit/")!,
|
||||
modifiedAt: nil, modifiedPrecision: nil, modifiedTimezone: nil, packageSHA256: checksum(exclusiveDiskPackage),
|
||||
byteSize: Int64(exclusiveDiskPackage.count), languageStatus: "english",
|
||||
metadata: .object(["system": .string("CoCo 3"), "owned_game": owned]),
|
||||
setup: .init(status: "spot-checked", command: "DOS\r", instructions: "Authored metadata fixture; do not use Play for this non-bootable disk.",
|
||||
configuration: configuration, selectedMembers: selected, reasons: [], validation: validation),
|
||||
assets: [art], downloadURLs: [exclusiveDiskURL])
|
||||
return SoftwareLibraryCatalog(titles: [.init(id: exclusiveTitleID, name: "Fixture Orbit", identityStatus: "authored-ui-fixture", releases: [release])],
|
||||
metadata: ["schema_version": "1", "recipe_contract": "2", "stage": "authored-exclusive-ui-fixture"])
|
||||
}
|
||||
/// Prepopulate only the isolated UI profile's verified passive assets. The
|
||||
/// shared reader/artwork actors therefore perform no network request.
|
||||
static func seedExclusiveAssets(manualDirectory: URL, artworkDirectory: URL) throws {
|
||||
guard exclusiveEnabled else { return }
|
||||
try FileManager.default.createDirectory(at: manualDirectory, withIntermediateDirectories: true)
|
||||
try exclusiveManual.write(to: manualDirectory.appendingPathComponent(checksum(exclusiveManual) + ".pdf"), options: .atomic)
|
||||
try FileManager.default.createDirectory(at: artworkDirectory, withIntermediateDirectories: true)
|
||||
let art = exclusiveCatalog.releases[0].assets[0]
|
||||
try exclusiveArtwork.write(to: artworkDirectory.appendingPathComponent(SoftwareLibraryArtworkCache.cacheKey(for: art) + ".png"), options: .atomic)
|
||||
}
|
||||
static func exclusiveData(for url: URL?) -> Data? {
|
||||
guard let url else { return nil }
|
||||
if url == exclusiveSourceURL { return exclusiveSourceBytes }
|
||||
if url == exclusiveDiskURL { return exclusiveDiskPackage }
|
||||
if url == exclusiveManualURL { return exclusiveManual }
|
||||
if url == exclusiveArtworkURL { return exclusiveArtwork }
|
||||
return nil
|
||||
}
|
||||
/// Minimal deterministic stored ZIP writer for these authored files. It
|
||||
/// supplies normal regular-file attributes; production uses the safe reader.
|
||||
private static func storedZIP(_ files: [(String, Data)]) -> Data {
|
||||
func word(_ value: UInt32, bytes: Int) -> Data {
|
||||
Data((0..<bytes).map { UInt8(truncatingIfNeeded: value >> (8 * $0)) })
|
||||
}
|
||||
func crc(_ bytes: Data) -> UInt32 {
|
||||
var value = UInt32.max
|
||||
for byte in bytes {
|
||||
value ^= UInt32(byte)
|
||||
for _ in 0..<8 { value = value & 1 == 1 ? (value >> 1) ^ 0xedb88320 : value >> 1 }
|
||||
}
|
||||
return value ^ UInt32.max
|
||||
}
|
||||
var output = Data(), central = Data()
|
||||
for (name, data) in files {
|
||||
let path = Data(name.utf8), size = UInt32(data.count), hash = crc(data), offset = UInt32(output.count)
|
||||
for (value, bytes) in [(UInt32(0x04034b50), 4), (20, 2), (0, 2), (0, 2), (0, 2), (0, 2),
|
||||
(hash, 4), (size, 4), (size, 4), (UInt32(path.count), 2), (0, 2)] { output.append(word(value, bytes: bytes)) }
|
||||
output.append(path); output.append(data)
|
||||
for (value, bytes) in [(UInt32(0x02014b50), 4), (0x0314, 2), (20, 2), (0, 2), (0, 2), (0, 2), (0, 2),
|
||||
(hash, 4), (size, 4), (size, 4), (UInt32(path.count), 2), (0, 2), (0, 2), (0, 2), (0, 2),
|
||||
(UInt32(0o100644) << 16, 4), (offset, 4)] { central.append(word(value, bytes: bytes)) }
|
||||
central.append(path)
|
||||
}
|
||||
let offset = UInt32(output.count); output.append(central)
|
||||
for (value, bytes) in [(UInt32(0x06054b50), 4), (0, 2), (0, 2), (UInt32(files.count), 2),
|
||||
(UInt32(files.count), 2), (UInt32(central.count), 4), (offset, 4), (0, 2)] { output.append(word(value, bytes: bytes)) }
|
||||
return output
|
||||
}
|
||||
}
|
||||
|
||||
private final class LibraryFixtureAttempts: @unchecked Sendable {
|
||||
private let lock = NSLock()
|
||||
private var value = 0
|
||||
func next() -> Int { lock.lock(); defer { lock.unlock() }; value += 1; return value }
|
||||
}
|
||||
|
||||
private final class LibraryFixtureURLProtocol: URLProtocol, @unchecked Sendable {
|
||||
private static let attempts = LibraryFixtureAttempts()
|
||||
private let lock = NSLock()
|
||||
private var cancelled = false
|
||||
private var pending: DispatchWorkItem?
|
||||
override class func canInit(with request: URLRequest) -> Bool { true }
|
||||
override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }
|
||||
override func startLoading() {
|
||||
if SoftwareLibraryInstallFixture.exclusiveEnabled {
|
||||
guard let data = SoftwareLibraryInstallFixture.exclusiveData(for: request.url), let url = request.url else {
|
||||
client?.urlProtocol(self, didFailWithError: URLError(.unsupportedURL)); return
|
||||
}
|
||||
let response = HTTPURLResponse(url: url, statusCode: 200, httpVersion: "HTTP/1.1",
|
||||
headerFields: ["Content-Type": "application/octet-stream", "Content-Length": String(data.count)])!
|
||||
client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
|
||||
client?.urlProtocol(self, didLoad: data); client?.urlProtocolDidFinishLoading(self)
|
||||
return
|
||||
}
|
||||
if SoftwareLibraryInstallFixture.playEnabled {
|
||||
guard let data = SoftwareLibraryInstallFixture.playData(for: request.url), let url = request.url else {
|
||||
client?.urlProtocol(self, didFailWithError: URLError(.unsupportedURL)); return
|
||||
}
|
||||
let response = HTTPURLResponse(url: url, statusCode: 200, httpVersion: "HTTP/1.1",
|
||||
headerFields: ["Content-Type": "application/octet-stream", "Content-Length": String(data.count)])!
|
||||
client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
|
||||
client?.urlProtocol(self, didLoad: data)
|
||||
client?.urlProtocolDidFinishLoading(self)
|
||||
return
|
||||
}
|
||||
guard request.url == SoftwareLibraryInstallFixture.downloadURL else {
|
||||
client?.urlProtocol(self, didFailWithError: URLError(.unsupportedURL)); return
|
||||
}
|
||||
let attempt = Self.attempts.next()
|
||||
if attempt == 1 {
|
||||
let response = HTTPURLResponse(url: request.url!, statusCode: 503, httpVersion: "HTTP/1.1", headerFields: ["Content-Length": "0"])!
|
||||
client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
|
||||
client?.urlProtocolDidFinishLoading(self)
|
||||
return
|
||||
}
|
||||
let data = SoftwareLibraryInstallFixture.bytes
|
||||
let response = HTTPURLResponse(url: request.url!, statusCode: 200, httpVersion: "HTTP/1.1",
|
||||
headerFields: ["Content-Type": "application/octet-stream", "Content-Length": String(data.count)])!
|
||||
client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
|
||||
client?.urlProtocol(self, didLoad: data.prefix(data.count / 2))
|
||||
let work = DispatchWorkItem { [weak self] in
|
||||
guard let self else { return }
|
||||
self.lock.lock(); let cancelled = self.cancelled; self.lock.unlock()
|
||||
guard !cancelled else { return }
|
||||
self.client?.urlProtocol(self, didLoad: data.suffix(data.count / 2))
|
||||
self.client?.urlProtocolDidFinishLoading(self)
|
||||
}
|
||||
lock.lock(); pending = work; let stopped = cancelled; lock.unlock()
|
||||
if stopped { work.cancel(); return }
|
||||
// Long enough for an actual Cancel click, then a quick retry completes.
|
||||
DispatchQueue.global(qos: .utility).asyncAfter(deadline: .now() + (attempt == 2 ? 10 : 0.2), execute: work)
|
||||
}
|
||||
override func stopLoading() {
|
||||
lock.lock(); cancelled = true; pending?.cancel(); pending = nil; lock.unlock()
|
||||
}
|
||||
}
|
||||
#endif
|
||||
Reference in new issue
Block a user