DevService

- changes to RealWorldRouting
-DevelopmentService for remote development with VSCode on the simulation nodes

Author: amdfxlucas

examples/scion/S08_real_world/README.md

@@ -0,0 +1,50 @@
+# Networking Application Development in SEED
+
+//### Connect the simulation to the 'real world' outside Internet
+
+
+This example is similar to `A03_real_world`
+
+ A real-world AS included in the emulation
+will collect the real network prefixes from the real Internet,
+and announce them inside the emulator. Packets reaching this AS
+will exit the emulator and be routed to the real destination.
+Responses from the outside will come back to this real-world AS
+and be routed to the final destination in the emulator.
+
+
+
+The DevelopmentService prepares a node for [Remote Development with VSCode](https://code.visualstudio.com/docs/remote/remote-overview).
+It installs the VSCode Remote Server on the Node during the docker image build, which allows to ssh into the running container later i.e. to debug software.
+
+As of now the primary anticipated use of the seed-emulator has been the deployment of fully developed applications into an emulated szenario i.e. to observe its behaviour.
+
+The DevService adapts the emulators primary paradigm of deploying fully develped applications into an emulated szenario,
+ to meet the need of developing i.e. P2P software to maturity in a distributed environment.
+
+The DevService allows for each individual node that it is installed on, to specify one or more Git repositories that shall be checked out
+(along with the desired filesystem path and branch) as well as the VSCode Extensions required for the projects software stack
+(i.e. golang.Go for the SCION-proto implementation which is written in Go)
+The DevService takes care to install the entirety of build and analysis tools that are needed for a given programming language at docker image build time (for Go this being i.e. the compiler, language server gopls, debugger delve) so that no annoying time delay arises once the emulator is running and you want to attach to a container.
+Any specified Git repositories are checked out on its own separate docker volume, for the changes to persist between runs of the simulator in case one forgets to push.
+
+Since software development requires a 'real Internet' connection of the container be it to git push/pull or fetch project dependencies for a build (i.e. go get, cargo build etc. )
+ This is achieved by promoting the nodes default gateway ( router node ) in the simulation into a 'RealWorldRouter' (which has access to the `000_svc` service network)
+Use of a separate service network inhibits 'short-circuiting' the simulated network topology (i.e. any crosstalk past the intended network topo among nodes)
+
+
+```
+    devsvc = GolangDevService('jane.doe', '[email protected]')
+    repo_url = 'https://github.com/scionproto/scion.git'
+    repo_branch = 'v0.12.0'
+    repo_path = '/home/root/repos/scion'
+
+    svc = devsvc.install(f'dev_152_cs1')
+    svc.checkoutRepo(repo_url, repo_path, repo_branch, AccessMode.shared)
+    emu.addBinding(Binding(f'dev_152_cs1', filter=Filter(nodeName=as152_cs1.getName(), asn=152)))
+
+    svc3 = devsvc.install(f'dev_153_cs1')
+    svc3.checkoutRepo(repo_url, repo_path, repo_branch, AccessMode.shared)
+    emu.addBinding(Binding(f'dev_153_cs1', filter=Filter(nodeName=as153_cs1.getName(), asn=153)))
+
+```

examples/scion/S08_real_world/scion_dev_service.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+# encoding: utf-8
+
+
+from seedemu.services import GolangDevService, AccessMode
+from seedemu.core import Emulator, Binding, Filter
+  
+from seedemu.compiler import Docker
+from seedemu.core import Emulator
+from seedemu.layers import ScionBase, ScionRouting, ScionIsd, Scion
+from seedemu.layers.Scion import LinkType as ScLinkType
+
+from seedemu.compiler import Docker, Platform
+import os, sys
+
+def run(dumpfile = None):
+    ###############################################################################
+    # Set the platform information
+    if dumpfile is None:
+        script_name = os.path.basename(__file__)
+
+        if len(sys.argv) == 1:
+            platform = Platform.AMD64
+        elif len(sys.argv) == 2:
+            if sys.argv[1].lower() == 'amd':
+                platform = Platform.AMD64
+            elif sys.argv[1].lower() == 'arm':
+                platform = Platform.ARM64
+            else:
+                print(f"Usage:  {script_name} amd|arm")
+                sys.exit(1)
+        else:
+            print(f"Usage:  {script_name} amd|arm")
+            sys.exit(1)
+    
+    # Initialize
+    emu = Emulator()
+    base = ScionBase()
+    routing = ScionRouting()
+    scion_isd = ScionIsd()
+    scion = Scion()
+
+    devsvc = GolangDevService('jane.doe', '[email protected]')
+    repo_url = 'https://github.com/scionproto/scion.git'
+    repo_branch = 'v0.12.0'
+    repo_path = '/home/root/repos/scion'
+                 
+
+
+    # SCION ISDs
+    base.createIsolationDomain(1)
+
+    # Internet Exchange
+    base.createInternetExchange(100, create_rs=False)
+
+    # AS-150
+    as150 = base.createAutonomousSystem(150)
+    scion_isd.addIsdAs(1, 150, is_core=True)
+    as150.createNetwork('net0')
+    as150.createControlService('cs1').joinNetwork('net0')
+    as150_router = as150.createRealWorldRouter('br0', prefixes=['10.150.0.0/24'])# the 'auto' gen prefix of net0
+    # expectation: hosts from within AS150 can ping outside world i.e. 8.8.8.8
+    #   Hosts in the other ASes can't!!
+    as150_router.joinNetwork('net0').joinNetwork('ix100')
+    as150_router.crossConnect(153, 'br0', '10.50.0.2/29')
+
+    # AS-151
+    as151 = base.createAutonomousSystem(151)
+    scion_isd.addIsdAs(1, 151, is_core=True)
+    as151.createNetwork('net0')
+    as151.createControlService('cs1').joinNetwork('net0')
+    as151.createRouter('br0').joinNetwork('net0').joinNetwork('ix100')
+
+    # AS-152
+    as152 = base.createAutonomousSystem(152)
+    scion_isd.addIsdAs(1, 152, is_core=True)
+    as152.createNetwork('net0')
+    as152_cs1 = as152.createControlService('cs1').joinNetwork('net0')
+    as152.createRouter('br0').joinNetwork('net0').joinNetwork('ix100')
+
+    # AS-153
+    as153 = base.createAutonomousSystem(153)
+    scion_isd.addIsdAs(1, 153, is_core=False)
+    scion_isd.setCertIssuer((1, 153), issuer=150)
+    as153.createNetwork('net0')
+    as153_cs1 = as153.createControlService('cs1').joinNetwork('net0') 
+    
+    as153_router = as153.createRouter('br0')
+    as153_router.joinNetwork('net0')
+    as153_router.crossConnect(150, 'br0', '10.50.0.3/29')
+
+    # Inter-AS routing
+    scion.addIxLink(100, (1, 150), (1, 151), ScLinkType.Core)
+    scion.addIxLink(100, (1, 151), (1, 152), ScLinkType.Core)
+    scion.addIxLink(100, (1, 152), (1, 150), ScLinkType.Core)
+    scion.addXcLink((1, 150), (1, 153), ScLinkType.Transit)
+
+    svc = devsvc.install(f'dev_152_cs1')
+    svc.checkoutRepo(repo_url, repo_path, repo_branch, AccessMode.shared)
+    emu.addBinding(Binding(f'dev_152_cs1', filter=Filter(nodeName=as152_cs1.getName(), asn=152)))
+
+    svc3 = devsvc.install(f'dev_153_cs1')
+    svc3.checkoutRepo(repo_url, repo_path, repo_branch, AccessMode.shared)
+    emu.addBinding(Binding(f'dev_153_cs1', filter=Filter(nodeName=as153_cs1.getName(), asn=153)))
+
+    # Rendering
+    emu.addLayer(base)
+    emu.addLayer(routing)
+    emu.addLayer(scion_isd)
+    emu.addLayer(scion)
+    emu.addLayer(devsvc)
+
+
+    if dumpfile is not None:
+        emu.dump(dumpfile)
+    else:
+        emu.render()
+
+        ###############################################################################
+        # Compilation 
+
+        emu.compile(Docker(platform=platform), './output', override=True)
+
+if __name__ == "__main__":
+    run()

seedemu/core/AutonomousSystem.py

@@ -9,7 +9,7 @@
 from .Emulator import Emulator
 from .Configurable import Configurable
 from .Customizable import Customizable
-from .Node import RealWorldRouter
+from .Node import promote_to_real_world_router, RealWorldRouterMixin
 from ipaddress import IPv4Network
 from typing import Dict, List
 import requests
@@ -102,17 +102,22 @@ def registerNodes(self, emulator: Emulator):
 
         for val in list(self.__nets.values()):
             net: Network = val
+            # Rap creates a new node for the provider and thus has to be set up
+            # before node registration
             if net.getRemoteAccessProvider() != None:
                 rap = net.getRemoteAccessProvider()
 
                 brNode = self.createRouter('br-{}'.format(net.getName()))
                 brNet = emulator.getServiceNetwork()
 
                 rap.configureRemoteAccess(emulator, net, brNode, brNet)
+            # .. whereas RealWorldConnectivity doesn't, so it can be moved to a later point
+            #  (after the services[which might require real-world-access] have been configured)
+            #if (p:=net.getExternalConnectivityProvider()) != None:
+            #    p.configureExternalLink(emulator, net, localNet of brNode , emulator.getServiceNet() )
 
-        for router in list(self.__routers.values()):
-            if issubclass(router.__class__, RealWorldRouter):
-                router.joinNetwork(emulator.getServiceNetwork().getName())
+        if any([issubclass(r.__class__, RealWorldRouterMixin) for r in list(self.__routers.values())]):
+            _ = emulator.getServiceNetwork() # this will construct and register Svc Net with registry
 
         for (key, val) in self.__nets.items(): reg.register(str(self.__asn), 'net', key, val)
         for (key, val) in self.__hosts.items(): reg.register(str(self.__asn), 'hnode', key, val)
@@ -127,10 +132,10 @@ def inheritOptions(self, emulator: Emulator):
                       if scope==str(self.getAsn()) and typ in ['rnode','hnode','csnode','rsnode'] ]
         for n in all_nodes:
             self.handDown(n)
-    
+
     def scope(self)-> Scope:
         """return a scope specific to this AS"""
-        return Scope(ScopeTier.AS, as_id=self.getAsn())    
+        return Scope(ScopeTier.AS, as_id=self.getAsn())
 
 
     def configure(self, emulator: Emulator):
@@ -234,9 +239,8 @@ def createRealWorldRouter(self, name: str, hideHops: bool = True, prefixes: List
         """
         assert name not in self.__routers, 'Router with name {} already exists.'.format(name)
 
-        router: RealWorldRouter = Router(name, NodeRole.Router, self.__asn)
-        router.__class__ = RealWorldRouter
-        router.initRealWorld(hideHops)
+        router: RealWorldRouterMixin = Router(name, NodeRole.Router, self.__asn)
+        router = promote_to_real_world_router(router, hideHops)
 
         if prefixes == None:
             prefixes = self.getPrefixList()

seedemu/core/Binding.py

@@ -230,7 +230,7 @@ def getCandidate(self, vnode: str, emulator: Emulator, peek: bool = False) -> No
         candidates: List[Node] = []
 
         for (scope, type, name), obj in registry.getAll().items():
-            if type != 'hnode': continue
+            if type not in ['hnode', 'rnode', 'csnode']: continue
             node: Node = obj
             filter = self.filter