@k8ts/instruments 0.6.0 → 0.6.2

package/src/{manifest → core/manifest}/index.ts

@@ -1,20 +1,15 @@
-import { Embedder } from "../_embedder/base"
-import { ResourceEntity } from "../graph/resource-node"
-export interface ManifestMetadata {
+import { Embedder } from "../../utils/embedder"
+import { Resource_Entity } from "../graph/resource/entity"
+export interface Manifest_Metadata {
     labels: Record<string, string>
     annotations: Record<string, string>
     name: string
     namespace?: string
 }
-export interface ManifestIdentFields {
+export interface Manifest_Ident {
     kind: string
     apiVersion: string
 }
-export interface BuilderInputTypes {
-    body: PreManifest
-    metadata?: ManifestMetadata
-    idents?: ManifestIdentFields
-}
 
 export type JsonSerializable =
     | string
@@ -24,16 +19,7 @@ export type JsonSerializable =
     | JsonSerializable[]
     | { [key: string]: JsonSerializable }
 
-export interface PreManifest {
-    metadata?: {
-        name?: string
-        namespace?: string
-        annotations?: Record<string, string>
-        labels?: Record<string, string>
-    }
-}
-export interface BaseManifest {
-    [key: string]: JsonSerializable
+export interface Manifest {
     [key: number]: never
     apiVersion: string
     kind: string
@@ -45,9 +31,8 @@ export interface BaseManifest {
     }
 }
 
-export interface SpecManifest<T extends JsonSerializable> extends BaseManifest {
+export interface SpecManifest<T extends JsonSerializable> extends Manifest {
     spec: T
 }
 
-export const ManifestSourceEmbedder = new Embedder<object, ResourceEntity>("ManifestSource")
-export * from "./manifest-builder"
+export const ManifestSourceEmbedder = new Embedder<object, Resource_Entity>("ManifestSource")

package/src/{tracing → core/tracing}/git.ts

@@ -1,3 +1,4 @@
+import { Meta } from "@k8ts/metadata"
 import dayjs from "dayjs"
 import simpleGit from "simple-git"
 
@@ -17,12 +18,20 @@ export interface GitTraceProps {
 export class GitTrace {
     private constructor(readonly props: GitTraceProps) {}
 
-    get text() {
+    get metaFields() {
         const hashPart = this.props.commit.sha.slice(0, 7)
         const shortDate = dayjs(this.props.commit.date).format("YYYY-MM-DD")
         const shortMessage = this.props.commit.message.split("\n")[0].slice(0, 20)
         const author = this.props.commit.author
-        return `${hashPart} '${shortMessage}⋯' (${author}@${shortDate})`
+
+        return Meta.make({
+            "git.k8ts.org/": {
+                "^sha": hashPart,
+                "^message": shortMessage,
+                "^author": author,
+                "^date": shortDate
+            }
+        })
     }
 
     static async make(options?: Partial<GitTraceOptions>) {
@@ -31,7 +40,15 @@ export class GitTrace {
             absolute: false,
             ...options
         }
-        const sg = simpleGit(options.cwd)
+        try {
+            var sg = simpleGit(options.cwd)
+        } catch (err: any) {
+            if (err.code === "ENOENT") {
+                console.warn(`Git not found or not a repo; skipping git trace.`)
+                return undefined
+            }
+            throw err
+        }
         const isRepo = await sg.checkIsRepo()
         if (!isRepo) {
             return undefined

package/src/{tracing → core/tracing}/traced.ts

@@ -1,4 +1,4 @@
-import { Embedder } from "../_embedder"
+import { Embedder } from "../../utils/embedder"
 import { Trace } from "./trace"
 
 export const TraceEmbedder = new Embedder<object, Trace>("TRACED")

package/src/error.ts

@@ -7,9 +7,3 @@ export class InstrumentsError extends Error {
         Object.assign(this, details)
     }
 }
-
-export class ProxyOperationError extends InstrumentsError {
-    constructor(message: string, details: Record<string, any> = {}) {
-        super(message, details)
-    }
-}

package/src/expressions/data-sources/index.ts

@@ -0,0 +1,147 @@
+import { doddle, DoddleAsync, seq, type Doddle } from "doddle"
+import { readFile } from "fs/promises"
+import { dirname, join, resolve } from "path"
+import StackTracey from "stacktracey"
+import { InstrumentsError } from "../../error"
+export type DataSource_LocalFile_Mode = "text" | "binary"
+
+export interface DataSource_LocalFile_Props<Mode extends DataSource_LocalFile_Mode = "text"> {
+    pointOfCall: StackTracey
+    path: string
+    cwd?: string
+    mode?: Mode
+}
+export class DataSource_LocalFile<Mode extends DataSource_LocalFile_Mode = "text"> {
+    constructor(private readonly _props: DataSource_LocalFile_Props<Mode>) {}
+
+    get cwd() {
+        if (this._props.cwd) {
+            return this._props.cwd
+        }
+        const where = this._props.pointOfCall.at(0)
+        return dirname(where.file)
+    }
+
+    get path() {
+        const where = this._props.pointOfCall.at(0)
+        const joined = join(dirname(where.file), this._props.path)
+        return resolve(joined)
+    }
+
+    contents = doddle(async () => {
+        const mode = this._props.mode ?? "text"
+        if (mode === "binary") {
+            const data = await readFile(this.path, null)
+            return data
+        }
+        return readFile(this.path, "utf-8")
+    }) as DoddleAsync<Mode extends "text" ? string : Uint8Array>
+}
+
+export function localFile<Mode extends DataSource_LocalFile_Mode = "text">(
+    path: string,
+    props?: Pick<DataSource_LocalFile_Props<Mode>, "cwd" | "mode">
+): DataSource_LocalFile<Mode>
+export function localFile(
+    args: TemplateStringsArray,
+    ...params: any[]
+): DataSource_LocalFile<"text">
+export function localFile(args: any, ...params: any[]) {
+    if (typeof args === "string") {
+        const options = params[0] ?? {}
+        return new DataSource_LocalFile({
+            pointOfCall: new StackTracey().slice(1),
+            path: args,
+            ...(options ?? {})
+        })
+    }
+    const path = String.raw(args, ...params)
+    return new DataSource_LocalFile({
+        pointOfCall: new StackTracey().slice(1),
+        path
+    })
+}
+
+export interface TypedArrayLike {
+    buffer: ArrayBuffer
+    byteLength: number
+}
+export type DataSource_Text = DataSource_LocalFile<"text"> | string
+export type DataSource_Binary = DataSource_LocalFile<"binary"> | TypedArrayLike | ArrayBuffer
+export type DataSourceRecord_Text = Record<string, DataSource_Text>
+export type DataSourceRecord_Binary = Record<string, DataSource_Binary>
+export type DataSourceRecord = DataSourceRecord_Text | DataSourceRecord_Binary
+export function isTypedArray(data: DataSource_Binary): data is TypedArrayLike {
+    return (
+        typeof data === "object" &&
+        "buffer" in data &&
+        "byteSize" in data &&
+        typeof data.byteSize === "number"
+    )
+}
+export function isArrayBuffer(data: DataSource_Binary): data is ArrayBuffer {
+    return data instanceof ArrayBuffer
+}
+export interface DataSourceResolvedRecord {
+    data: Record<string, string>
+    binaryData: Record<string, Uint8Array>
+}
+type MaybePromise<T> = T | Promise<T>
+async function promiseAllMap<K, V>(m: Map<K, Doddle<MaybePromise<V>>>): Promise<Map<K, V>> {
+    const promises = seq(m)
+        .map(async x => [x[0], await x[1].pull()] as [K, V])
+        .toArray()
+        .pull()
+    const res = await Promise.all(promises)
+    return new Map(res)
+}
+export async function resolveText(record: DataSourceRecord_Text) {
+    const mp = seq(Object.entries(record))
+        .map(([k, v]) => {
+            return [
+                k,
+                doddle(async () => {
+                    let resolved = v
+                    if (v instanceof DataSource_LocalFile) {
+                        resolved = await v.contents.pull()
+                    }
+                    if (typeof resolved !== "string") {
+                        throw new InstrumentsError(
+                            `Got an invalid data value ${v} for key ${k}. Must be a string.`
+                        )
+                    }
+                    return resolved
+                })
+            ] as const
+        })
+        .toMap(x => x)
+        .pull()
+    return promiseAllMap(mp)
+}
+export async function resolveBinary(record: DataSourceRecord_Binary) {
+    const mp = seq(Object.entries(record))
+        .map(([k, v]) => {
+            return [
+                k,
+                doddle(async () => {
+                    let resolved = v as any
+                    if (v instanceof DataSource_LocalFile) {
+                        resolved = await v.contents.pull()
+                    }
+                    if (isTypedArray(resolved)) {
+                        return new Uint8Array(resolved.buffer)
+                    } else if (isArrayBuffer(resolved)) {
+                        return new Uint8Array(resolved)
+                    } else {
+                        throw new InstrumentsError(
+                            `Got an invalid data value ${v} for key ${k}. Must be binary data.`
+                        )
+                    }
+                })
+            ] as const
+        })
+        .toMap(x => x)
+        .pull()
+
+    return promiseAllMap(mp)
+}

package/src/expressions/index.ts

@@ -0,0 +1,5 @@
+export * from "./data-sources"
+export * from "./network"
+export * from "./quantities"
+export * from "./timezone"
+export * from "./workload"

package/src/expressions/network/index.ts

@@ -0,0 +1 @@
+export * from "./ports"

package/src/{ports → expressions/network/ports}/index.ts

@@ -2,7 +2,7 @@ import { PortSet } from "./set"
 import type { InputPortSetRecord } from "./types"
 export { PortMap } from "./map"
 export { PortSet } from "./set"
-export { InputPortMapping, InputPortSetRecord, PortMapEntry, PortSetEntry } from "./types"
+export type { InputPortMapping, InputPortSetRecord, PortMapEntry, PortSetEntry } from "./types"
 export function ports<Names extends string>(input: InputPortSetRecord<Names>): PortSet<Names> {
     return PortSet.make(input)
 }

package/src/{ports → expressions/network/ports}/map.ts

@@ -1,4 +1,4 @@
-import { Map } from "immutable"
+import { filterMap, mapValues } from "@k8ts/metadata/util"
 import { PortError } from "./error"
 import type { PortMapEntry } from "./types"
 export class PortMap<Names extends string> {
@@ -9,7 +9,7 @@ export class PortMap<Names extends string> {
     }
 
     pick<InNames extends Names>(...name: InNames[]): PortMap<InNames> {
-        return this._apply(map => map.filter((_, key) => name.includes(key as InNames)))
+        return this._apply(map => filterMap(map, (_, key) => name.includes(key as InNames)))
     }
 
     get values() {
@@ -18,7 +18,7 @@ export class PortMap<Names extends string> {
 
     map(mapping: Record<Names, number>): PortMap<Names> {
         return new PortMap(
-            this._map.map(entry => {
+            mapValues(this._map, entry => {
                 return {
                     ...entry,
                     frontend: mapping[entry.name as keyof typeof mapping]

package/src/{ports → expressions/network/ports}/set.ts

@@ -1,5 +1,6 @@
 import { Meta } from "@k8ts/metadata"
-import { Map } from "immutable"
+import { filterMap, mapValues, merge } from "@k8ts/metadata/util"
+import { seq } from "doddle"
 import { PortError } from "./error"
 import { PortMap } from "./map"
 import { parsePortInput, portRecordInput } from "./tools/entry"
@@ -14,7 +15,7 @@ import type {
 
 declare const __NAMES__: unique symbol
 export class PortSet<Names extends string = never> {
-    constructor(private readonly _map: Map<Names, PortSetEntry> = Map()) {
+    constructor(private readonly _map: Map<Names, PortSetEntry> = new Map()) {
         for (const entry of _map.values()) {
             Meta._checkNameValue(`container port '${entry.name}' (${entry.port})`, entry.name)
         }
@@ -25,7 +26,7 @@ export class PortSet<Names extends string = never> {
     }
 
     union<InNames extends string>(other: PortSet<InNames>): PortSet<Names | InNames> {
-        return new PortSet(this._map.merge(other._map))
+        return new PortSet(merge(this._map, other._map))
     }
     add<Name extends string>(
         name: Name,
@@ -46,16 +47,16 @@ export class PortSet<Names extends string = never> {
         }
         return this._apply(map => {
             const processed = portRecordInput(a)
-            return map.merge(processed)
+            return merge(map, processed)
         })
     }
 
     pick<InNames extends Names>(...name: InNames[]): PortSet<InNames> {
-        return this._apply(map => map.filter((_, key) => name.includes(key as InNames))) as any
+        return this._apply(map => filterMap(map, (_, key) => name.includes(key as InNames))) as any
     }
 
     get names() {
-        return this._map.keySeq().toArray() as Names[]
+        return seq(this._map.keys()).toArray().pull() as Names[]
     }
 
     get(name: Names): PortSetEntry {
@@ -71,7 +72,7 @@ export class PortSet<Names extends string = never> {
 
     map(mapping: InputPortMapping<Names>): PortMap<Names> {
         return new PortMap(
-            this._map.map(entry => {
+            mapValues(this._map, entry => {
                 if (!(entry.name in mapping)) {
                     throw new PortError(`Port ${entry.name} not found in mapping`)
                 }

package/src/{ports → expressions/network/ports}/tools/entry.ts

@@ -1,5 +1,5 @@
-import { Map } from "immutable"
-import { Ip4 } from "../../_ip"
+import { seq } from "doddle"
+import { Ip4 } from "../../ip"
 import { PortSet } from "../set"
 import type {
     InputPortSetEntry,
@@ -39,6 +39,8 @@ export function portRecordInput(
     if (record instanceof PortSet) {
         return record.values
     }
-    const inputMap = Map(record)
-    return inputMap.map((v, k) => parsePortInput(k, v))
+    const inputMap = seq(Object.entries(record))
+        .toMap(([k, v]) => [k, parsePortInput(k, v)])
+        .pull()
+    return inputMap
 }

package/src/{ports → expressions/network/ports}/types.ts

@@ -1,4 +1,4 @@
-import { Ip4, Ip4_String } from "../_ip"
+import type { Ip4, Ip4_String } from "../ip"
 
 export interface PortSpecObj {
     port: Port

package/src/expressions/quantities/index.ts

@@ -0,0 +1,2 @@
+export * from "./reqlem"
+export * from "./units"

package/src/expressions/quantities/reqlem/objects.ts

@@ -0,0 +1,107 @@
+import { mapFromObject, mapValues } from "@k8ts/metadata/util"
+import { seq } from "doddle"
+import { isEmpty, merge } from "lodash"
+import { string, type Parjser } from "parjs"
+import { mapConst, or } from "parjs/combinators"
+import { InstrumentsError } from "../../../error"
+import type { UnitParser, UnitValue } from "../units"
+import { AnyUnitParser } from "../units/unit-parser"
+import { createResourceParser } from "./parser"
+import type { ReqLimit, Resources_ReqLimits_Trait, Resources_UnitMap_Trait } from "./types"
+
+export class Resources_Map<const RM extends Resources_UnitMap_Trait<RM>> {
+    constructor(private _map: Map<string, ReqLimit>) {}
+
+    toObject() {
+        const kubernetesForm = mapValues(this._map, (value, key) => {
+            const result = {} as any
+            if (value.request) {
+                result.requests = {
+                    [key]: value.request.val
+                }
+            }
+            if (value.limit) {
+                result.limits = {
+                    [key]: value.limit.val
+                }
+            }
+            if (!isEmpty(result)) {
+                return result
+            }
+            return undefined
+        })
+
+        return merge({}, ...kubernetesForm.values())
+    }
+}
+
+export class ResourcesSpec<const RM extends Resources_UnitMap_Trait<RM>> {
+    readonly _unitParsers: Map<string, Parjser<UnitValue | undefined>>
+    readonly _reqLimitParsers: Map<string, Parjser<ReqLimit>>
+    readonly _anyUnitParser = AnyUnitParser.make()
+    readonly _anyReqLimitParser = createResourceParser(this._anyUnitParser)
+    constructor(_unitMap: Map<string, UnitParser>) {
+        const questionMarkParser = string("?").pipe(mapConst(undefined))
+        this._unitParsers = mapValues(_unitMap, parser =>
+            parser.parser.pipe(or(questionMarkParser))
+        )
+        this._reqLimitParsers = mapValues(_unitMap, parser => createResourceParser(parser))
+    }
+
+    private _parseUnitValue(resource: string, input: string): UnitValue | undefined {
+        const pUnitValue = this._unitParsers.get(input)
+        if (!pUnitValue) {
+            throw new InstrumentsError(`No parser found for ${input}`)
+        }
+        return pUnitValue.parse(input).value
+    }
+
+    private _parseReqLimit(resource: string, input: string): ReqLimit {
+        const pReqLimit = this._reqLimitParsers.get(resource)
+        if (!pReqLimit) {
+            return this._anyReqLimitParser.parse(input).value
+        }
+        return pReqLimit.parse(input).value
+    }
+    __INPUT__!: Resources_ReqLimits_Trait<RM>
+
+    parse<const R extends Resources_ReqLimits_Trait<RM>>(input: R): Resources_Map<RM> {
+        const allKeys = new Set([...Object.keys(input), ...this._unitParsers.keys()])
+        const map = seq(allKeys)
+            .toMap(key => {
+                const getVal = () => {
+                    const value = input[key as keyof R]
+                    const pUnitValue = this._unitParsers.get(key) ?? this._anyUnitParser.parser
+                    if (!pUnitValue) {
+                        throw new InstrumentsError(`No parser found for ${String(key)}`)
+                    }
+                    if (!value) {
+                        throw new InstrumentsError(`No value found for ${String(key)}`)
+                    }
+
+                    if (Array.isArray(value)) {
+                        const [req, limit] = value.map(v => {
+                            return pUnitValue.parse(v as any).value
+                        })
+                        return {
+                            request: req,
+                            limit: limit
+                        }
+                    } else if (typeof value === "string") {
+                        return this._parseReqLimit(key as string, value)
+                    } else {
+                        throw new InstrumentsError(`Invalid value for resource ${String(key)}`)
+                    }
+                }
+                return [key, getVal()] as const
+            })
+            .pull()
+        return new Resources_Map(map as Map<string, ReqLimit>)
+    }
+
+    static make<const RM extends Resources_UnitMap_Trait<RM>>(unitMap: {
+        [K in keyof RM]: UnitParser<RM[K]>
+    }) {
+        return new ResourcesSpec<RM>(mapFromObject(unitMap as any) as Map<string, UnitParser>)
+    }
+}

package/src/expressions/quantities/reqlem/types.ts

@@ -0,0 +1,28 @@
+import type { UnitValue } from "../units/unit-parser"
+export type Resources_sUnitTerm<Unit extends string> = `${number}${Unit}` | "?"
+
+export type ReqLim_Array<Unit extends string> = [
+    Resources_sUnitTerm<Unit>,
+    Resources_sUnitTerm<Unit>
+]
+export type Resources_UnitMap_Trait<T> = Record<keyof T, string>
+type _Spaces = "" | " " | "  "
+export type Resources_sToFrom<Unit extends string> =
+    `${Resources_sUnitTerm<Unit>}${_Spaces}->${_Spaces}${Resources_sUnitTerm<Unit>}`
+export type Resources_sExactly<U extends string> = `=${Resources_sUnitTerm<U>}`
+export interface ReqLimit<Unit extends string = string> {
+    readonly request?: UnitValue<Unit>
+    readonly limit?: UnitValue<Unit>
+}
+export type ReqLim_Input_Of<Unit extends string> =
+    | Resources_sToFrom<Unit>
+    | Resources_sExactly<Unit>
+    | ReqLim_Array<Unit>
+type CustomResource = `${string}/${string}`
+
+export type Resources_ReqLimits_Trait<ResourceUnit extends Resources_UnitMap_Trait<ResourceUnit>> =
+    {
+        [K in keyof ResourceUnit]: ReqLim_Input_Of<ResourceUnit[K]>
+    } & {
+        [K in CustomResource]?: ReqLim_Input_Of<string>
+    }

package/src/{units → expressions/quantities/units}/unit-parser.ts

@@ -1,7 +1,6 @@
-import type { Set } from "immutable"
 import { int, letter, type Parjser } from "parjs"
 import { many, map, stringify, then } from "parjs/combinators"
-import { InstrumentsError } from "../error"
+import { InstrumentsError } from "../../../error"
 const pUnit = letter().pipe(many(), stringify())
 
 const pValueUnit = int().pipe(

package/src/{units → expressions/quantities/units}/units.ts

@@ -1,4 +1,3 @@
-import { Set } from "immutable"
 import { SetUnitParser } from "./unit-parser"
 
 export type G = `${number}G`
@@ -45,9 +44,9 @@ export namespace Unit {
     export type Time = m | h | d | s | ms
     export type Any = Data | Cpu | Time
 
-    export const Cpu = SetUnitParser.make("cpu", Set(["m"]))
+    export const Cpu = SetUnitParser.make("cpu", new Set(["m"]))
 
-    export const Data = SetUnitParser.make("data", Set(["M", "G", "T", "K", "Mi", "Gi", "Ki"]))
+    export const Data = SetUnitParser.make("data", new Set(["M", "G", "T", "K", "Mi", "Gi", "Ki"]))
 
-    export const Time = SetUnitParser.make("time", Set(["m", "h", "d", "s", "ms"]))
+    export const Time = SetUnitParser.make("time", new Set(["m", "h", "d", "s", "ms"]))
 }