conlink 2.0.1 → 2.0.2

package/old/net2dot.py

@@ -1,122 +0,0 @@
-#!/usr/bin/env -S python3 -u
-
-# Copyright (c) 2021, Viasat, Inc
-# Licensed under MPL 2.0
-
-import re, sys, yaml
-
-NODE_PROPS = 'shape=box style=filled penwidth=1'
-CONTAINER_PROPS = 'fontsize = 12 style = filled fillcolor = "#e1d5e7" color = "#9673a6"'
-NETWORK_PROPS = '%s penwidth = 2' % CONTAINER_PROPS
-INTF_PROPS = 'width=0.1 height=0.1 fontsize=10 fillcolor="#ffbb9e" color="#d7db00"'
-SWITCH_PROPS = 'fontsize=12 style="rounded,filled" fillcolor="#dae8fc" color="#6c8ebf"'
-HOST_PROPS = 'fontsize=12 fillcolor="#f5f5f5" color="#666666"'
-
-def id(n):
-    return re.sub(r"-", "_", n)
-
-def intfText(cluster, intf):
-    name = intf.get('intf', intf.get('origName', intf.get('name')))
-    if name.startswith('DUMMY_'):
-        return '%s__%s [shape=point style=invis]' % (
-                id(cluster), id(name))
-    else:
-        ip = intf.get('ip', intf.get('opts', {}).get('ip', ''))
-        if ip: ip = "\\n%s" % ip
-        return '%s__%s [label="%s%s" %s]' % (
-                id(cluster), id(name), name, ip, INTF_PROPS)
-
-if __name__ == '__main__':
-
-    networkFile = sys.argv[1]
-    networkName = sys.argv[2]
-
-    netCfg = yaml.full_load(open(networkFile))
-    if 'services' in netCfg:
-        netService = re.sub(r'_1$', '', networkName)
-        netCfg = netCfg['services'][netService]['x-network']
-    mnCfg = netCfg['mininet-cfg']
-
-    links = []
-    containers = {}
-    containers[networkName] = {'nodes': []}
-    namespaces = {}
-
-    for link in netCfg.get('links', []):
-        l, r = link['left'], link['right']
-        clname, crname = l['container'], r['container']
-        ilname, irname = l['intf'], r['intf']
-        links.append([(clname, ilname), (crname, irname)])
-        for cname, intf in [(clname, l), (crname, r)]:
-            if cname not in containers:
-                containers[cname] = {'nodes': []}
-            containers[cname]['nodes'].append(intf)
-
-    for lk in mnCfg.get('links', []):
-        l, r = lk['left'], lk['right']
-        links.append([(networkName, l), (networkName, r)])
-
-    for s in mnCfg.get('switches', []):
-        namespaces[s['name']] = {'interfaces': [], 'type': 'switch', **s}
-    for h in mnCfg.get('hosts', []):
-        namespaces[h['name']] = {'interfaces': [], 'type': 'host', **h}
-
-    for i in mnCfg.get('interfaces', []):
-        nm, nd = i.get('origName', i['name']), i['node']
-        if nd in namespaces:
-            namespaces[nd]['interfaces'].append(i)
-        else:
-            links.append([(networkName, nm), (networkName, nd)])
-
-    # Make sure all namespaces have at least one interface so that
-    # they can be connected by edges (lhead, ltail)
-    for nsname, nsdata in namespaces.items():
-        if not nsdata['interfaces']:
-            nsdata['interfaces'].append({'name': 'DUMMY_%s' % nsname})
-
-    ###
-
-    print('digraph D {')
-    print('  splines = true;')
-    print('  compound = true;')
-    print('  node [%s];' % NODE_PROPS)
-
-    for cname, cdata in containers.items():
-        print('  subgraph cluster_%s {' % id(cname))
-        print('    label = "%s";' % cname)
-        if cname == networkName:
-            print('    %s;' % NETWORK_PROPS)
-        else:
-            print('    %s;' % CONTAINER_PROPS)
-        for node in cdata['nodes']:
-            print('    %s;' % intfText(node['container'], node))
-        # mininet/network interface is processed after container links
-        # so that the mininet/network definitions take precedence
-        if cname == networkName:
-            for nsname, nsdata in namespaces.items():
-                print('    subgraph cluster_%s__%s {' % (
-                    id(cname), id(nsname)))
-                print('      label = "%s";' % nsname)
-                if nsdata['type'] == 'switch':
-                    print('      %s;' % SWITCH_PROPS)
-                else:
-                    print('      %s;' % HOST_PROPS)
-                for intf in nsdata['interfaces']:
-                    print('      %s;' % intfText(cname, intf))
-                print('    }')
-        print("  }")
-
-    for ((lc, ln), (rc, rn)) in links:
-        extra=''
-        if lc == networkName and ln in namespaces:
-            iname = namespaces[ln]['interfaces'][0]['name']
-            extra += ' ltail=cluster_%s__%s' % (id(networkName), id(ln))
-            ln = id(iname)
-        if rc == networkName and rn in namespaces:
-            iname = namespaces[rn]['interfaces'][0]['name']
-            extra += ' lhead=cluster_%s__%s' % (id(networkName), id(rn))
-            rn = id(iname)
-        print('  %s__%s -> %s__%s [dir=none%s];' % (
-            id(lc), id(ln), id(rc), id(rn), extra))
-
-    print("}")

package/old/notes-old.txt

@@ -1,97 +0,0 @@
-- MVP for ViaBox:
-    - [x] compose/x-network file loading
-    - [x] multiple config sources and merging
-    - [x] link route config
-    - [x] filtering on project and workdir
-    - [x] interface and MAC iteration
-    - [x] variable templating
-    - [ ] *vlan type interfaces
-
-- Near term:
-    - [ ] dummy interfaces
-    - [ ] schema validation
-    - [ ] tc/qdisc settings
-    - [ ] arbitrary container commands
-
-- Further term:
-    - [ ] CNI networking support
-    - [ ] tunnel interfaces
-    - [ ] multiple routes
-    - [ ] ovs flow config
-    - [ ] Multiple bridge-modes
-        - bridge-mode as part of the domain definition so that the
-          same conlink instances can support multiple bridge modes
-          simultaneously (with a default for links that don't
-          specify).
-    - [ ] CNI model:
-        - conlink runs in container listening for events on a UDS
-          (intead of docker events)
-        - an outer conlink command is the CNI client that formats
-          events to send over the UDS to the inner conlink
-
-- Also see schema-ish.yaml
-links:
-  - type: TYPE         # Default: domain.
-                       # Others: dummy, tunnel, host, *vlan, etc
-
-    domain: DOMAIN     # ovs switch name
-
-    container: FOO     # full container name
-      # OR
-    service: FOO       # compose service name
-
-    interface: INTF    # internal container interface name
-
-    # --- optional general ---
-
-    ip(s): IP          # starting address, can include net slash to limit max
-    mac: MAC
-    mtu: MTU
-    route(s): ROUTE    # `ip route add ROUTE`, maybe add "dev INTF" automatically
-    tc(s): TC          # tc/qdisc commands/settings
-    flow(s): FLOW      # `ovs-ofctl add-flow DOMAIN FLOW`. With var templating.
-    command(s): CMD    # arbitrary shell cmd. After all links setup for this container
-
-    # --- optional for 'type:' links ---
-
-    host-intf: INTF    # host interface to *vlan or move in
-    mode: MODE         # bridge, etc
-    vlanid: VLANID     # VLAN #
-    nat: NAT           # nat target
-
-
-- type maps to 'ip link' type with default of 'veth'
-- 
-- when type is 'veth', then base default is 'conlink'
-- when type is 'veth' and base is 'conlink', then bridge is required.
-
-- conlink veth link: {type: veth [DEFAULT], base: conlink [DEFAULT], bridge: BRIDGE, dev: DEV}
-
-
-
-Dependencies in python version:
-- argparse
-- shlex (parsing commands)
-- compose_interpolation import TemplateWithDefaults
-- cerberus import Validator
-    - options: joi, ajv, json-schema, and z-schema.
-- docker
-- psutil (pid_exists)
-- json
-- yaml
-- mininet
-
-
-- [deprecated idea] conlink sub-commands:
-    conlink spit
-        - output override docker-compose file with conlink service
-        - figure out volume mounts to get to other compose file(s)
-    conlink dc up ...
-        - generate override docker-compose file with conlink service
-        - run the compose command with override file
-    conlink start 
-        - start inside compose
-    conlink run
-        - start outside compose
-
-

package/old/package.json

@@ -1,16 +0,0 @@
-{
-  "name": "conlink",
-  "dependencies": {
-    "@exodus/schemasafe": "^1.3.0",
-    "ajv": "^8.12.0",
-    "dockerode": "^3.3.4",
-    "joi": "^17.10.2",
-    "nbb": "^1.2.178",
-    "neodoc": "^2.0.2",
-    "yaml": "^2.2.1"
-  },
-  "devDependencies": {
-    "shadow-cljs": "^2.25.7",
-    "source-map-support": "^0.5.21"
-  }
-}

package/old/schema.yaml

@@ -1,138 +0,0 @@
-links:
-  type: list
-  schema:
-    type: dict
-    schema:
-      left:
-        type: dict
-        required: true
-        schema:
-          container: {type: string, required: true}
-          intf:      {type: string, required: true}
-          ip:        {type: string, required: false,
-                      regex: '([0-9]+\.){3}[0-9]+\/[0-9]+'}
-          mac:       {type: string, required: false,
-                      regex: '([0-9A-Fa-f][0-9A-Fa-f]:){5}[0-9A-Fa-f][0-9A-Fa-f]'}
-      right:
-        type: dict
-        required: true
-        schema:
-          container: {type: string, required: true}
-          intf:      {type: string, required: true}
-          ip:        {type: string, required: false,
-                      regex: '([0-9]+\.){3}[0-9]+\/[0-9]+'}
-          mac:       {type: string, required: false,
-                      regex: '([0-9A-Fa-f][0-9A-Fa-f]:){5}[0-9A-Fa-f][0-9A-Fa-f]'}
-
-tunnels:
-  type: list
-  schema:
-    type: dict
-    schema:
-      type:      {type: string, required: true}
-      intf:      {type: string, required: true}
-      vni:       {type: number, required: true}
-      remote:    {type: string, required: true,
-                  regex: '([0-9]+\.){3}[0-9]+'}
-      ip:        {type: string, required: false,
-                  regex: '([0-9]+\.){3}[0-9]+\/[0-9]+'}
-      mac:       {type: string, required: false,
-                  regex: '([0-9A-Fa-f][0-9A-Fa-f]:){5}[0-9A-Fa-f][0-9A-Fa-f]'}
-      link_args: {type: string, required: false}
-
-interfaces:
-  type: list
-  schema:
-    type: dict
-    required: true
-    schema:
-      type:      {type: string, required: true,
-                  allowed: [link, vlan, macvlan, macvtap, ipvlan, ipvtap]}
-      container: {type: string, required: true}
-      host-intf: {type: string, required: true}
-      intf:      {type: string, required: true}
-      mode:      {type: string, required: false,
-                  dependencies: {type: [macvlan, macvtap, ipvlan, ipvtap]}}
-      vlanid:    {type: number, required: false,
-                  dependencies: {type: [vlan]}}
-      ip:        {type: string, required: false,
-                  regex: '([0-9]+\.){3}[0-9]+\/[0-9]+'}
-      nat:       {type: string, required: false,
-                  regex: '([0-9]+\.){3}[0-9]+',
-                  dependencies: ip}
-
-network-settings: {type: string}
-
-commands:
-  type: list
-  schema:
-    type: dict
-    schema:
-      container: {type: string, required: true}
-      command:
-        required: true
-        oneof: [ {type: string}, {type: list, schema: {type: string}} ]
-
-mininet-cfg:
-  type: dict
-  schema:
-
-    switches:
-      type: list
-      required: false
-      schema:
-        type: dict
-        schema:
-          name: {type: string, required: true}
-          opts: {type: dict,   required: false}
-
-    hosts:
-      type: list
-      required: false
-      schema:
-        type: dict
-        schema:
-          name: {type: string, required: true}
-          opts: {type: dict,   required: false}
-
-    containers:
-      type: list
-      required: false
-      schema:
-        type: dict
-        schema:
-          name: {type: string, required: true}
-          opts: {type: dict,   required: false}
-
-    links:
-      type: list
-      required: false
-      schema:
-        type: dict
-        schema:
-          left:  {type: string, required: true}
-          right: {type: string, required: true}
-          opts:  {type: dict,   required: false}
-
-    interfaces:
-      type: list
-      required: false
-      schema:
-        type: dict
-        schema:
-          node:     {type: string, required: true}
-          name:     {type: string, required: true}
-          origName: {type: string, required: false}
-          opts:     {type: dict,   required: false}
-
-    commands:
-      type: list
-      required: false
-      schema:
-        type: dict
-        schema:
-          node: {type: string,  required: true}
-          sync: {type: boolean, required: false}
-          command:
-            required: true
-            oneof: [ {type: string}, {type: list, schema: {type: string}} ]

package/old/schema.yaml.bak

@@ -1,76 +0,0 @@
-$defs:
-  one_link:
-
-type: object
-additionalProperties: false
-required: ["links"]
-properties:
-  links:
-    type: array
-    items:
-      type: object
-#      oneOf: [{required: ["container"]},
-#              {required: ["service"]},
-#              #{required: ["bridge"], properties: {type: {const: {oneOf: ["geneve", "vxlan"]}}}}]
-#              #{properties: {type: {const: "geneve"}}, required: ["bridge"]},
-#              #{properties: {type: {const: "vxlan"}}, required: ["bridge"]}
-#              {allOf: [{properties: {type: {const: "geneve"}}},
-#                       {properties: {type: {const: "vxlan"}}}]}
-#              ]
-
-#      if:   {properties: {type: {const: "veth"}}}
-#      then:
-#        allOf:
-#          - {required: ["bridge"]}
-#          - {not: {required: ["vlanid", "vni", "remote"]}}
-#      else:
-#        not: {required: ["bridge"]}
-#        if:   {properties: {type: {const: "vlan"}}}
-#        then: {required: ["vlanid"]}
-#        else: {not: {required: ["vlanid"]}}
-
-      allOf:
-        - if:   {properties: {type: {const: "veth"}}}
-          then: {required: ["bridge"]}
-          else: {not: {required: ["BOGUS"]}}
-        - if:   {properties: {type: {const: "geneve"}}}
-          then: {required: ["bridge", "remote", "vni"]}
-          #else: {not: {required: ["bridge", "remote", "vni"]}}
-          else: {not: {required: ["BOGUS"]}}
-        - if:   {properties: {type: {const: "vxlan"}}}
-          then: {required: ["bridge", "remote", "vni"]}
-          #else: {not: {required: ["bridge", "remote", "vni"]}}
-          else: {not: {required: ["BOGUS"]}}
-
-      additionalProperties: false
-      properties:
-        type:
-          type: string
-          default: "veth"
-          enum: [veth, dummy, vlan, ipvlan, ipvtap, macvlan, macvtap, geneve, vxlan]
-        service:   {type: string}
-        container: {type: string}
-        bridge:    {type: string}
-        dev:       {type: string, default: "eth0"}
-        ip:        {type: string, pattern: "^([0-9]{1,3}[.]){3}[0-9]+/[0-9]*$"}
-        mac:       {type: string, pattern: "^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$"}
-        mtu:       {type: number}
-        route:     {type: string}
-    
-        vlanid:    {type: number}
-        nat:       {type: string, pattern: "^([0-9]{1,3}[.]){3}[0-9]+/[0-9]*$"}
-    
-        vni:       {type: number}
-        remote:    {type: string, pattern: "^([0-9]{1,3}[.]){3}[0-9]+$"}
-
-  commands:
-    type: array
-    items:
-      type: object
-      required: ["command"]
-      oneOf: [{required: ["container"]},
-              {required: ["service"]}]
-      properties:
-        service:   {type: string}
-        container: {type: string}
-        command:   {type: string}

package/old/set-cover-old.cljs

@@ -1,205 +0,0 @@
-#!/usr/bin/env nbb
-
-(ns set-cover
-  (:require [clojure.set :refer [union]]
-            [clojure.string :as S]
-            [promesa.core :as P]
-            ["path" :as path]
-            ["fs/promises" :as fs]))
-
-(defn set-covers-with-alts
-  "Return all the set covers of a graph containing alternation nodes"
-  ([graph start] (set-covers-with-alts graph [] #{} [start]))
-  ([graph result visited pending]
-   (loop [result result  visited visited  pending pending]
-     (let [[node & pending] pending]
-       (if (coll? node)
-         (mapcat
-           (fn [node]
-             (let [[result visited] (if (contains? visited node)
-                                      [result visited]
-                                      [(conj result node) (conj visited node)])
-                   pending (into (vec pending) [node])]
-               (set-covers-with-alts graph result visited pending)))
-           node)
-         (let [[result visited] (if (contains? visited node)
-                                  [result visited]
-                                  [(conj result node) (conj visited node)])
-               children (filter #(not (contains? visited %)) (graph node))
-               pending (into (vec pending) (vec children))]
-           (if (empty? pending)
-             [result]
-             (recur result visited pending))))))))
-
-(defn min-set-cover-with-alts
-  "Call set-covers-with-alts and then return shortest path (if tie
-  then picks first)."
-  [graph start]
-  (let [[start graph] (if (coll? start)
-                        [:START (merge graph {:START (set start)})]
-                        [start graph])
-        covers (set-covers-with-alts graph start)
-        counts (group-by count covers)
-        smallest (apply min (keys counts))]
-    (-> (get counts smallest) first next)))
-
-(defn deps-split [s] (if (empty? s) [] (S/split s #"[, \n]+")))
-
-(defn load-deps 
-  [path start-deps]
-  (P/let [add-deps #(reduce (fn [g [a b]] (update g a (fnil conj []) b)) %1 %2)
-          pending (map #(vector :START %)
-                       (deps-split (S/join "," start-deps)))]
-    (P/loop [graph (add-deps {} pending)
-             pending pending
-             visited #{}]
-      (prn :graph graph)
-      (P/let [[[node dep] & pending] pending]
-        (if (not dep)  ;; done
-          graph
-          (if (contains? visited dep)  ;; already processed
-            (P/recur graph pending visited)
-            (P/let [file (path/join path dep "deps")
-                    content (P/catch (fs/readFile file "utf8") #(identity ""))
-                    deps (map #(vector dep %) (deps-split content))]
-              (P/recur (add-deps graph deps)
-                       (apply conj pending deps)
-                       (conj visited dep)))))))))
-
-(P/let [graph (load-deps "./modes1" *command-line-args*)
-        modes (min-set-cover-with-alts graph :START)]
-  (prn :graph graph)
-  (prn :modes modes))
-
-#_(def start-deps (deps-split (S/join "," *command-line-args*)))
-
-#_(defn load-deps
-  [graph path node children]
-  (P/let [children (filter #(not (contains? graph %)) children)
-          _ (prn :load-deps :path path :node node :children children)
-          graph (reduce (fn [g dep]
-                          (update g node (fnil conj []) dep))
-                        graph children)
-          contents (P/all (for [child children]
-                            (P/let [file (path/join path child "deps")
-                                    content (P/catch (fs/readFile file "utf8")
-                                              #(identity ""))]
-
-                              (println "  " :file file :node child :content (S/trimr content))
-                              [child (S/trimr content)])))
-          _ (println "    " :contents contents)
-          node-children (->> (for [[node child-content] contents
-                                   :when (not (empty? child-content))]
-                               [node (deps-split (S/join "," child-content))])
-                             (apply concat))]
-    ;;(println "  " :node-children node-children)
-    (P/loop [graph graph
-             node-children node-children]
-      (if (empty? node-children)
-        graph
-        (P/let [[node children] node-children
-                new-graph (load-deps graph path node children)]
-          (P/recur new-graph (next node-children)))))))
-
-#_(P/let [d (load-deps {} "./modes1" :START start-deps)]
-  (prn :result d))
-
-
-;;(prn :start-deps start-deps)
-;;(P/loop [node :START
-;;         files start-deps
-;;         graph (reduce (fn [g dep] (update g :START (fnil conj []) dep))
-;;                       {} files)
-;;         contents (P/all (for [node deps]
-;;                           (P/let [file node
-;;                                   content (P/catch (fs/readFile file "utf8")
-;;                                             #(identity ""))]
-;;                             [node content])))]
-;;  (P/let [graph 
-;;          contents (P/all (for [file files]
-;;                            (P/let [content (P/catch (fs/readFile file "utf8")
-;;                                              #(identity ""))]
-;;                              [file content])))
-;;          graph (reduce (fn [g [dep content]]
-;;                          (update g (fnil conj []) dep 
-;;                                  ))
-;;                          graph cotents)
-;;          ]
-;;    (if (empty? contents)
-;;      (prn :graph graph)
-;;      (P/recur )
-;;      )))
-;;
-;;  (P/let [contents (P/all (for [file files]
-;;                            (P/let [content (P/catch (fs/readFile file "utf8")
-;;                                              #(identity ""))]
-;;                              [file content])))
-;;          graph (reduce (fn [g [dep content]]
-;;                          (update g (fnil conj []) dep 
-;;                          )
-;;                        graph cotents)
-;;          _ (prn :here3)
-;;          exists (P/catch (P/do (fs/access file) true) #(identity false))
-;;          _ (prn :exists exists)
-;;          content (if exists
-;;                    (fs/readFile (first pending) "utf8")
-;;                    nil)
-;;          pending (if content
-;;                    (apply conj pending (S/split #"[, \n]" content))
-;;                    pending)
-;;          graph (into graph
-;;                      (for []))]
-;;    (prn :file file :content content :pending pending)
-;;    (if pending
-;;      (P/recur pending)
-;;      graph)))
-;;
-;;(fs/exists "/etc/passwd")
-
-
-(comment
-
-(def graph0
-  {:A [:B :C]
-   :B [:C :D]
-   :C [:E]
-   :E [:F]})
-
-(prn :results (min-set-cover-with-alts graph0 :A))
-
-(def graph1
-  {:A [:B [:C :D]]  ; A requires B AND (C OR D)
-   :B [:E :F]       ; B requires E AND F
-   :C [:G]          ; C requires G
-   :D [:G :H]       ; D requires G AND H
-   :E []            ; E has no deps
-   :F []            ; F has no deps
-   :G []            ; G has no deps
-   :H []})          ; H has no deps
-
-(prn :result1 (min-set-cover-with-alts graph1 :A))
-
-(def graph2
-  {:A     [:B :C]
-   :B     [[:C :D]]
-   :C     [:E]
-   :D     [:E]})
-
-(prn :result2 (min-set-cover-with-alts graph2 :A))
-
-(def graph3
-  {:accel [:base [:mach3 :ab]]
-   :mach3 [:base]
-   :ab    [:base]})
-
-(prn :result3.1 (min-set-cover-with-alts graph3 [:accel :ab]))
-(prn :result3.2 (min-set-cover-with-alts graph3 [:accel :mach3]))
-
-(def graph4
-  {:A     [:B :C]
-   :B     [[:D :C]]})
-
-(prn :result4-all (set-covers-with-alts graph4 :A))
-(prn :result4-min (min-set-cover-with-alts graph4 :A))
-
-)