@highstate/library 0.9.16 → 0.9.19

package/src/k8s.ts

@@ -1,638 +0,0 @@
-import { defineEntity, defineUnit, Type, type Static } from "@highstate/contract"
-import { Literal } from "@sinclair/typebox"
-import * as dns from "./dns"
-import { l3EndpointEntity, l4EndpointEntity } from "./network"
-import { serverEntity } from "./common"
-import { arrayPatchModeSchema } from "./utils"
-
-export const fallbackKubeApiAccessSchema = Type.Object({
-  serverIp: Type.String(),
-  serverPort: Type.Number(),
-})
-
-export const tunDevicePolicySchema = Type.Union([
-  Type.Object({
-    type: Literal("host"),
-  }),
-  Type.Object({
-    type: Literal("plugin"),
-    resourceName: Type.String(),
-    resourceValue: Type.String(),
-  }),
-])
-
-export const externalServiceTypeSchema = Type.StringEnum(["NodePort", "LoadBalancer"])
-export const scheduleOnMastersPolicySchema = Type.StringEnum(["always", "when-no-workers", "never"])
-export const cniSchema = Type.StringEnum(["cilium", "other"])
-
-export const clusterQuirksSchema = Type.Object({
-  /**
-   * The IP and port of the kube-apiserver available from the cluster.
-   *
-   * Will be used to create fallback network policy in CNIs which does not support allowing access to the kube-apiserver.
-   */
-  fallbackKubeApiAccess: Type.Optional(fallbackKubeApiAccessSchema),
-
-  /**
-   * Specifies the policy for using the tun device inside containers.
-   *
-   * If not provided, the default policy is `host` which assumes just mounting /dev/net/tun from the host.
-   *
-   * For some runtimes, like Talos's one, the /dev/net/tun device is not available in the host, so the plugin policy should be used.
-   */
-  tunDevicePolicy: Type.Optional(tunDevicePolicySchema),
-
-  /**
-   * The service type to use for external services.
-   *
-   * If not provided, the default service type is `NodePort` since `LoadBalancer` may not be available.
-   */
-  externalServiceType: Type.Optional(externalServiceTypeSchema),
-})
-
-export const clusterInfoProperties = {
-  /**
-   * The unique identifier of the cluster.
-   *
-   * Should be defined as a UUID of the `kube-system` namespace which is always present in the cluster.
-   */
-  id: Type.String(),
-
-  /**
-   * The name of the cluster.
-   */
-  name: Type.String(),
-
-  /**
-   * The name of the CNI plugin used by the cluster.
-   *
-   * Supported values are:
-   * - `cilium`
-   * - `other`
-   */
-  cni: cniSchema,
-
-  /**
-   * The endpoints of the cluster nodes.
-   *
-   * The entry may represent real node endpoint or virtual endpoint (like a load balancer).
-   *
-   * The same node may also be represented by multiple entries (e.g. a node with private and public IP).
-   */
-  endpoints: Type.Array(l3EndpointEntity.schema),
-
-  /**
-   * The endpoints of the API server.
-   *
-   * The entry may represent real node endpoint or virtual endpoint (like a load balancer).
-   *
-   * The same node may also be represented by multiple entries (e.g. a node with private and public IP).
-   */
-  apiEndpoints: Type.Array(l4EndpointEntity.schema),
-
-  /**
-   * The external IPs of the cluster nodes allowed to be used for external access.
-   */
-  externalIps: Type.Array(Type.String()),
-
-  /**
-   * The extra quirks of the cluster to improve compatibility.
-   */
-  quirks: Type.Optional(clusterQuirksSchema),
-
-  /**
-   * The extra metadata to attach to the cluster.
-   */
-  metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
-} as const
-
-export const serviceTypeSchema = Type.StringEnum(["NodePort", "LoadBalancer", "ClusterIP"])
-
-export const metadataSchema = Type.Object({
-  name: Type.String(),
-  namespace: Type.String(),
-  labels: Type.Optional(Type.Record(Type.String(), Type.String())),
-  annotations: Type.Optional(Type.Record(Type.String(), Type.String())),
-})
-
-export const resourceSchema = Type.Object({
-  clusterId: Type.String(),
-  metadata: metadataSchema,
-})
-
-export const serviceEntity = defineEntity({
-  type: "k8s.service",
-
-  schema: Type.Object({
-    type: Type.Literal("k8s.service"),
-    ...resourceSchema.properties,
-    endpoints: Type.Array(l4EndpointEntity.schema),
-  }),
-
-  meta: {
-    color: "#2196F3",
-  },
-})
-
-export const clusterEntity = defineEntity({
-  type: "k8s.cluster",
-
-  schema: Type.Object({
-    ...clusterInfoProperties,
-    kubeconfig: Type.String(),
-  }),
-
-  meta: {
-    color: "#2196F3",
-  },
-})
-
-export const internalIpsPolicySchema = Type.StringEnum(["always", "public", "never"])
-
-export const scheduleOnMastersPolicyArgs = {
-  /**
-   * The policy for scheduling workloads on master nodes.
-   *
-   * - `always`: always schedule workloads on master nodes regardless of the number of workers;
-   * - `when-no-workers`: schedule workloads on master nodes only if there are no workers (default);
-   * - `never`: never schedule workloads on master nodes.
-   */
-  scheduleOnMastersPolicy: Type.Default(scheduleOnMastersPolicySchema, "when-no-workers"),
-}
-
-export const clusterInputs = {
-  masters: {
-    entity: serverEntity,
-    multiple: true,
-  },
-  workers: {
-    entity: serverEntity,
-    multiple: true,
-    required: false,
-  },
-} as const
-
-export const clusterOutputs = {
-  k8sCluster: clusterEntity,
-  apiEndpoints: {
-    entity: l4EndpointEntity,
-    multiple: true,
-  },
-  endpoints: {
-    entity: l3EndpointEntity,
-    multiple: true,
-  },
-} as const
-
-export const existingCluster = defineUnit({
-  type: "k8s.existing-cluster",
-
-  args: {
-    /**
-     * The list of external IPs of the cluster nodes allowed to be used for external access.
-     *
-     * If not provided, will be automatically detected by querying the cluster nodes.
-     */
-    externalIps: Type.Optional(Type.Array(Type.String())),
-
-    /**
-     * The policy for using internal IPs of the nodes as external IPs.
-     *
-     * - `always`: always use internal IPs as external IPs;
-     * - `public`: use internal IPs as external IPs only if they are (theoretically) routable from the public internet **(default)**;
-     * - `never`: never use internal IPs as external IPs.
-     */
-    internalIpsPolicy: Type.Default(internalIpsPolicySchema, "public"),
-
-    /**
-     * The extra quirks of the cluster to improve compatibility.
-     */
-    quirks: Type.Optional(clusterQuirksSchema),
-  },
-
-  secrets: {
-    /**
-     * The kubeconfig of the cluster to use for connecting to the cluster.
-     *
-     * Will be available for all components using `cluster` output of this unit.
-     */
-    kubeconfig: Type.Record(Type.String(), Type.Any()),
-  },
-
-  outputs: clusterOutputs,
-
-  meta: {
-    displayName: "Existing Cluster",
-    description: "An existing Kubernetes cluster.",
-    primaryIcon: "devicon:kubernetes",
-    category: "Kubernetes",
-  },
-
-  source: {
-    package: "@highstate/k8s",
-    path: "units/existing-cluster",
-  },
-})
-
-export const clusterPatch = defineUnit({
-  type: "k8s.cluster-patch",
-
-  args: {
-    /**
-     * The endpoints of the API server.
-     *
-     * The entry may represent real node endpoint or virtual endpoint (like a load balancer).
-     *
-     * The same node may also be represented by multiple entries (e.g. a node with private and public IP).
-     */
-    apiEndpoints: Type.Default(Type.Array(Type.String()), []),
-
-    /**
-     * The mode to use for patching the API endpoints.
-     *
-     * - `prepend`: prepend the new endpoints to the existing ones (default);
-     * - `replace`: replace the existing endpoints with the new ones.
-     */
-    apiEndpointsPatchMode: Type.Default(arrayPatchModeSchema, "prepend"),
-
-    /**
-     * The endpoints of the cluster nodes.
-     *
-     * The entry may represent real node endpoint or virtual endpoint (like a load balancer).
-     *
-     * The same node may also be represented by multiple entries (e.g. a node with private and public IP).
-     */
-    endpoints: Type.Default(Type.Array(Type.String()), []),
-
-    /**
-     * The mode to use for patching the endpoints.
-     *
-     * - `prepend`: prepend the new endpoints to the existing ones (default);
-     * - `replace`: replace the existing endpoints with the new ones.
-     */
-    endpointsPatchMode: Type.Default(arrayPatchModeSchema, "prepend"),
-  },
-
-  inputs: {
-    k8sCluster: clusterEntity,
-    apiEndpoints: {
-      entity: l4EndpointEntity,
-      required: false,
-      multiple: true,
-    },
-    endpoints: {
-      entity: l3EndpointEntity,
-      required: false,
-      multiple: true,
-    },
-  },
-
-  outputs: clusterOutputs,
-
-  meta: {
-    displayName: "Cluster Patch",
-    description: "Patches some properties of the cluster.",
-    primaryIcon: "devicon:kubernetes",
-    secondaryIcon: "fluent:patch-20-filled",
-    category: "Kubernetes",
-  },
-
-  source: {
-    package: "@highstate/k8s",
-    path: "units/cluster-patch",
-  },
-})
-
-export const clusterDns = defineUnit({
-  type: "k8s.cluster-dns",
-
-  args: {
-    ...dns.createArgs(),
-    ...dns.createArgs("api"),
-  },
-
-  inputs: {
-    k8sCluster: clusterEntity,
-    ...dns.inputs,
-  },
-
-  outputs: clusterOutputs,
-
-  meta: {
-    displayName: "Cluster DNS",
-    description: "Creates DNS records for the cluster and updates endpoints.",
-    primaryIcon: "devicon:kubernetes",
-    secondaryIcon: "mdi:dns",
-    category: "Kubernetes",
-  },
-
-  source: {
-    package: "@highstate/k8s",
-    path: "units/cluster-dns",
-  },
-})
-
-export const gatewayEntity = defineEntity({
-  type: "k8s.gateway",
-
-  schema: Type.Object({
-    clusterId: Type.String(),
-    gatewayClassName: Type.String(),
-    httpListenerPort: Type.Number(),
-    httpsListenerPort: Type.Number(),
-    endpoints: Type.Array(l3EndpointEntity.schema),
-  }),
-
-  meta: {
-    color: "#4CAF50",
-  },
-})
-
-export const tlsIssuerEntity = defineEntity({
-  type: "k8s.tls-issuer",
-
-  schema: Type.Object({
-    clusterId: Type.String(),
-    clusterIssuerName: Type.String(),
-  }),
-
-  meta: {
-    color: "#f06292",
-  },
-})
-
-export const accessPointEntity = defineEntity({
-  type: "k8s.access-point",
-
-  schema: Type.Object({
-    clusterId: Type.String(),
-    gateway: gatewayEntity.schema,
-    tlsIssuer: tlsIssuerEntity.schema,
-    dnsProviders: Type.Array(dns.providerEntity.schema),
-  }),
-
-  meta: {
-    color: "#F57F17",
-  },
-})
-
-export const accessPoint = defineUnit({
-  type: "k8s.access-point",
-
-  inputs: {
-    gateway: gatewayEntity,
-    tlsIssuer: tlsIssuerEntity,
-    dnsProviders: {
-      entity: dns.providerEntity,
-      multiple: true,
-    },
-  },
-
-  outputs: {
-    accessPoint: accessPointEntity,
-  },
-
-  meta: {
-    displayName: "Access Point",
-    description: "An access point which can be used to connect to services.",
-    primaryIcon: "mdi:access-point",
-    category: "Kubernetes",
-  },
-
-  source: {
-    package: "@highstate/k8s",
-    path: "units/access-point",
-  },
-})
-
-export const certManager = defineUnit({
-  type: "k8s.cert-manager",
-
-  inputs: {
-    k8sCluster: clusterEntity,
-  },
-
-  outputs: {
-    k8sCluster: clusterEntity,
-  },
-
-  meta: {
-    displayName: "Cert Manager",
-    description: "A certificate manager for managing TLS certificates.",
-    primaryIcon: "simple-icons:letsencrypt",
-    category: "Kubernetes",
-  },
-
-  source: {
-    package: "@highstate/k8s",
-    path: "units/cert-manager",
-  },
-})
-
-export const dns01TlsIssuer = defineUnit({
-  type: "k8s.dns01-issuer",
-
-  args: {
-    /**
-     * The top-level domains to filter the DNS01 challenge for.
-     *
-     * If not provided, will use all domains passed to the DNS providers.
-     */
-    domains: Type.Optional(Type.Array(Type.String())),
-  },
-
-  inputs: {
-    k8sCluster: clusterEntity,
-    dnsProviders: {
-      entity: dns.providerEntity,
-      multiple: true,
-    },
-  },
-
-  outputs: {
-    tlsIssuer: tlsIssuerEntity,
-  },
-
-  meta: {
-    displayName: "DNS01 Issuer",
-    description: "A TLS issuer for issuing certificate using DNS01 challenge.",
-    primaryIcon: "mdi:certificate",
-    category: "Kubernetes",
-  },
-
-  source: {
-    package: "@highstate/k8s",
-    path: "units/dns01-issuer",
-  },
-})
-
-export const deploymentEntity = defineEntity({
-  type: "k8s.deployment",
-
-  schema: Type.Object({
-    type: Type.Literal("k8s.deployment"),
-    ...resourceSchema.properties,
-    service: Type.Optional(serviceEntity.schema),
-  }),
-
-  meta: {
-    color: "#4CAF50",
-  },
-})
-
-export const statefulSetEntity = defineEntity({
-  type: "k8s.stateful-set",
-
-  schema: Type.Object({
-    type: Type.Literal("k8s.stateful-set"),
-    ...resourceSchema.properties,
-    service: serviceEntity.schema,
-  }),
-
-  meta: {
-    color: "#FFC107",
-  },
-})
-
-export const exposableWorkloadEntity = defineEntity({
-  type: "k8s.exposable-workload",
-
-  schema: Type.Union([deploymentEntity.schema, statefulSetEntity.schema]),
-
-  meta: {
-    color: "#4CAF50",
-  },
-})
-
-export const persistentVolumeClaimEntity = defineEntity({
-  type: "k8s.persistent-volume-claim",
-
-  schema: Type.Object({
-    type: Type.Literal("k8s.persistent-volume-claim"),
-    ...resourceSchema.properties,
-  }),
-
-  meta: {
-    color: "#FFC107",
-  },
-})
-
-export const interfaceEntity = defineEntity({
-  type: "k8s.interface",
-
-  schema: Type.Object({
-    name: Type.String(),
-    workload: exposableWorkloadEntity.schema,
-  }),
-
-  meta: {
-    color: "#2196F3",
-    description:
-      "The interface in a network space of pod kernel which can accept or transmit packets.",
-  },
-})
-
-export const gatewayApi = defineUnit({
-  type: "k8s.gateway-api",
-
-  inputs: {
-    k8sCluster: clusterEntity,
-  },
-
-  outputs: {
-    k8sCluster: clusterEntity,
-  },
-
-  meta: {
-    displayName: "Gateway API",
-    description: "Installs the Gateway API CRDs to the cluster.",
-    primaryIcon: "devicon:kubernetes",
-    secondaryIcon: "mdi:api",
-    secondaryIconColor: "#4CAF50",
-    category: "Kubernetes",
-  },
-
-  source: {
-    package: "@highstate/k8s",
-    path: "units/gateway-api",
-  },
-})
-
-export const cilium = defineUnit({
-  type: "k8s.cilium",
-
-  args: {
-    /**
-     * If set to `true`, the generated network policy will allow
-     * all DNS queries to be resolved, even if they are
-     * for forbidden (non-allowed) FQDNs.
-     *
-     * By default, is `false`.
-     */
-    allowForbiddenFqdnResolution: Type.Default(Type.Boolean(), false),
-  },
-
-  inputs: {
-    k8sCluster: clusterEntity,
-  },
-
-  outputs: {
-    k8sCluster: clusterEntity,
-  },
-
-  meta: {
-    displayName: "Cilium",
-    description: "The Cilium CNI deployed on Kubernetes.",
-    primaryIcon: "simple-icons:cilium",
-    secondaryIcon: "devicon:kubernetes",
-    category: "Kubernetes",
-  },
-
-  source: {
-    package: "@highstate/cilium",
-    path: "unit",
-  },
-})
-
-export const monitorWorkerResourceGroupSchema = Type.Object({
-  type: Type.StringEnum(["deployment", "statefulset", "pod", "service"]),
-  namespace: Type.String(),
-  names: Type.Optional(Type.Array(Type.String())),
-})
-
-export const monitorWorkerParamsSchema = Type.Object({
-  /**
-   * The ID of the secret containing the kubeconfig of the cluster.
-   */
-  kubeconfigSecretId: Type.String(),
-
-  /**
-   * The resources to monitor in the cluster.
-   */
-  resourceGroups: Type.Array(monitorWorkerResourceGroupSchema),
-})
-
-export type CNI = Static<typeof cniSchema>
-export type Cluster = Static<typeof clusterEntity.schema>
-
-export type Gateway = Static<typeof gatewayEntity.schema>
-export type TlsIssuer = Static<typeof tlsIssuerEntity.schema>
-export type AccessPoint = Static<typeof accessPointEntity.schema>
-
-export type Metadata = Static<typeof metadataSchema>
-export type Resource = Static<typeof resourceSchema>
-
-export type ServiceType = Static<typeof serviceTypeSchema>
-export type Service = Static<typeof serviceEntity.schema>
-
-export type Deployment = Static<typeof deploymentEntity.schema>
-export type ExposableWorkload = Static<typeof exposableWorkloadEntity.schema>
-
-export type PersistentVolumeClaim = Static<typeof persistentVolumeClaimEntity.schema>
-export type StatefulSet = Static<typeof statefulSetEntity.schema>
-
-export type Interface = Static<typeof interfaceEntity.schema>
-export type InternalIpsPolicy = Static<typeof internalIpsPolicySchema>
-
-export type MonitorWorkerParams = Static<typeof monitorWorkerParamsSchema>
-export type MonitorWorkerResourceGroup = Static<typeof monitorWorkerResourceGroupSchema>

package/src/timeweb.ts

@@ -1,75 +0,0 @@
-import { defineEntity, defineUnit, Type } from "@highstate/contract"
-import { serverEntity } from "./common"
-import { keyPairEntity } from "./ssh"
-
-export const connectionEntity = defineEntity({
-  type: "timeweb.connection",
-
-  schema: Type.Object({
-    name: Type.String(),
-    apiToken: Type.String(),
-  }),
-})
-
-export const connection = defineUnit({
-  type: "timeweb.connection",
-
-  secrets: {
-    apiToken: Type.String(),
-  },
-
-  outputs: {
-    connection: connectionEntity,
-  },
-
-  meta: {
-    displayName: "Timeweb Connection",
-    description: "Creates a new Timeweb connection.",
-    primaryIcon: "material-symbols:cloud",
-    category: "Timeweb",
-  },
-
-  source: {
-    package: "@highstate/timeweb",
-    path: "connection",
-  },
-})
-
-export const virtualMachine = defineUnit({
-  type: "timeweb.virtual-machine",
-
-  args: {
-    presetId: Type.Optional(Type.Number()),
-    osId: Type.Optional(Type.Number()),
-    availabilityZone: Type.String(),
-  },
-
-  inputs: {
-    connection: connectionEntity,
-    sshKeyPair: {
-      entity: keyPairEntity,
-      required: false,
-    },
-  },
-
-  secrets: {
-    sshPrivateKey: Type.Optional(Type.String()),
-  },
-
-  outputs: {
-    server: serverEntity,
-  },
-
-  meta: {
-    displayName: "Timeweb Virtual Machine",
-    description: "Creates a new Timeweb virtual machine.",
-    primaryIcon: "material-symbols:cloud",
-    secondaryIcon: "codicon:vm",
-    category: "Timeweb",
-  },
-
-  source: {
-    package: "@highstate/timeweb",
-    path: "virtual-machine",
-  },
-})

package/src/{obfuscators → k8s/obfuscators}/index.ts

@@ -1,2 +1,2 @@
-export * from "./shared"
 export * as phantun from "./phantun"
+export * from "./shared"