feat(cc): add reset command

- Add 'reset' to cc scorch component
- README updates and formatting
- Use self.mm property instead of passing around a mm object
- Handle cases where no cmd.type is specified
- Code cleanup

Author: GhostofGoes

src/python/phenix_apps/apps/scorch/cc/README.md

@@ -5,27 +5,47 @@ type: cc
 exe:  phenix-scorch-component-cc
 ```
 
+> NOTE: miniccc must be installed and running on the target VM(s).
+
 ## Metadata Options
 
-```
+```yaml
 metadata:
+  # Commands (types) to run for a particular stage (configure, start, stop, cleanup)
+  # NOTE: The stage-level types differ from the VM-level types
+  configure:
+    - type: reset  # delete all miniccc commands and responses
+  start: [] # same array of keys as above
+  stop: [] # same array of keys as above
+  cleanup: [] # same array of keys as above
+
+  # Commands to run for specific VMs, for a particular stage
   vms:
-  - hostname:
-    configure:
-    - type: exec # can be exec, background, send, or recv
-      args: whoami # a simple string of args (not an array)
-      once: <bool> # only execute a command once (applicable for exec and background) (default: true)
-      wait: <bool> # wait for cmd to be executed by VM (default: false)
-      validator: <bash script to validate exec results>
-    start: [] # same array of keys as above
-    stop: [] # same array of keys as above
-    cleanup: [] # same array of keys as above
+    - hostname:
+      configure:
+        - type: exec # can be exec, background, send, recv
+          args: whoami # a simple string of args (not an array)
+          once: <bool> # only execute a command once (applicable for exec and background) (default: true)
+          wait: <bool> # wait for cmd to be executed by VM (default: false)
+          validator: <bash script to validate exec results>
+      start: [] # same array of keys as above
+      stop: [] # same array of keys as above
+      cleanup: [] # same array of keys as above
 ```
 
 > The validator is only used when `type = exec` and forces `wait = true`. The
 > validator script should be written to process STDIN. Anything the validator
 > script writes to STDERR will be available to the user if the validation fails.
 
+## Types
+- VM-specific command types
+  - `exec`: execute a command (`cc exec`)
+  - `background`: execute a command in the background (component will continue)
+  - `send`: send a file (Host -> VM)
+  - `recv`: receive a file (VM -> Host)
+- Stage-level command types
+  - `reset`: reset miniccc state, by clearing filter and deleting all commands and responses. **WARNING**: THIS WILL INTERFERE WITH OPERATION OF MANY COMPONENTS! Reset should only be used at the start or end of a run or a loop (use with special care in loops!).
+
 ## Notes on the `exec` and `background` Type
 
 When a `cc` command is configured, minimega will send the command to a `miniccc`
@@ -68,6 +88,13 @@ host for the current scorch run, loop, and count.
 
 ```yaml
 components:
+  - name: reset_miniccc
+    type: cc
+    metadata:
+      configure:
+        - reset
+      cleanup:
+        - reset
   - name: disable-eth0
     type: cc
     metadata:

src/python/phenix_apps/apps/scorch/cc/cc.py

@@ -1,4 +1,7 @@
-import os, subprocess, sys, uuid
+import os
+import subprocess
+import sys
+import uuid
 
 from phenix_apps.apps.scorch import ComponentBase
 from phenix_apps.common import utils
@@ -10,28 +13,33 @@ def __init__(self):
 
         self.execute_stage()
 
-
     def configure(self):
         self.__run('configure')
 
-
     def start(self):
         self.__run('start')
 
-
     def stop(self):
         self.__run('stop')
 
-
     def cleanup(self):
         self.__run('cleanup')
 
-
-    def __run(self, stage):
+    def __run(self, stage: str) -> None:
         nodes = self.extract_node_names()
-        vms   = self.metadata.get('vms', [])
-
-        mm = self.mm_init()
+        vms = self.metadata.get('vms', [])
+        commands = self.metadata.get(stage, [])
+
+        for cmd in commands:
+            if cmd.type == 'reset':
+                self.print("deleting miniccc commands and responses")
+                self.mm.clear_cc_filter()
+                self.mm.cc_delete_command("all")
+                self.mm.cc_delete_response("all")
+                self.mm.clear_cc_commands()
+                self.mm.clear_cc_responses()
+            else:
+                self.eprint(f"Unknown command type '{cmd.type}' for stage '{stage}'")
 
         for vm in vms:
             if vm.hostname not in nodes:
@@ -55,10 +63,10 @@ def __run(self, stage):
 
                     self.print(f"executing command '{cmd.args}' in VM {vm.hostname}")
 
-                    script = self.__send_cmd_as_file(mm, vm.hostname, cmd.args)
+                    script = self.__send_cmd_as_file(vm.hostname, cmd.args)
 
                     if wait:
-                        results = utils.mm_exec_wait(mm, vm.hostname, script, once=once)
+                        results = utils.mm_exec_wait(self.mm, vm.hostname, script, once=once)
 
                         self.print(f"command '{cmd.args}' executed in VM {vm.hostname} using cc")
 
@@ -108,28 +116,29 @@ def __run(self, stage):
                             else:
                                 self.print('results are valid')
                     else:
-                        mm.cc_filter(f'name={vm.hostname}')
+                        self.mm.cc_filter(f'name={vm.hostname}')
 
                         if once:
-                            mm.cc_exec_once(script)
+                            self.mm.cc_exec_once(script)
                         else:
-                            mm.cc_exec(script)
+                            self.mm.cc_exec(script)
 
                         self.print(f"command '{cmd.args}' executed in VM {vm.hostname} using cc")
                 elif cmd.type == 'background':
                     once = cmd.get('once', True)
 
                     self.print(f"backgrounding command '{cmd.args}' in VM {vm.hostname} using cc")
 
-                    script = self.__send_cmd_as_file(mm, vm.hostname, cmd.args)
+                    script = self.__send_cmd_as_file(vm.hostname, cmd.args)
 
-                    mm.cc_filter(f'name={vm.hostname}')
+                    self.mm.cc_filter(f'name={vm.hostname}')
 
                     if once:
-                        mm.cc_background_once(script)
+                        self.mm.cc_background_once(script)
                     else:
-                        mm.cc_background(script)
+                        self.mm.cc_background(script)
 
+                    self.mm.clear_cc_filter()
                     self.print(f"command '{cmd.args}' backgrounded in VM {vm.hostname}")
                 elif cmd.type == 'send':
                     args = cmd.args.split(':')
@@ -154,7 +163,7 @@ def __run(self, stage):
                     self.print(f"sending file '{src}' to VM {vm.hostname} at '{dst}' using cc")
 
                     try:
-                        utils.mm_send(mm, vm.hostname, src, dst)
+                        utils.mm_send(self.mm, vm.hostname, src, dst)
                         self.print(f"file '{src}' sent to VM {vm.hostname} at '{dst}'")
                     except Exception as ex:
                         self.eprint(f"error sending '{src}' to VM {vm.hostname}: {ex}")
@@ -177,14 +186,22 @@ def __run(self, stage):
                     self.print(f"receiving file '{src}' from VM {vm.hostname} to `{dst}` using cc")
 
                     try:
-                        utils.mm_recv(mm, vm.hostname, src, dst)
+                        utils.mm_recv(self.mm, vm.hostname, src, dst)
                         self.print(f"file '{src}' received from VM {vm.hostname} to `{dst}`")
                     except Exception as ex:
                         self.eprint(f"error receiving '{src}' from VM {vm.hostname}: {ex}")
                         sys.exit(1)
-
-
-    def __send_cmd_as_file(self, mm, hostname, cmd):
+                elif cmd.type == 'reset':
+                    self.print("deleting miniccc commands and responses")
+                    self.mm.clear_cc_filter()
+                    self.mm.cc_delete_command("all")
+                    self.mm.cc_delete_response("all")
+                    self.mm.clear_cc_commands()
+                    self.mm.clear_cc_responses()
+                else:
+                    self.eprint(f"Unknown command type '{cmd.type}' for VM '{vm.hostname}' and stage '{stage}'")
+
+    def __send_cmd_as_file(self, hostname, cmd):
         cmd_file = f'run-{self.extract_run_name()}_{str(uuid.uuid4())}'
         node     = self.extract_node(hostname)
 
@@ -199,12 +216,13 @@ def __send_cmd_as_file(self, mm, hostname, cmd):
         with open(cmd_src, 'w') as f:
             f.write(cmd)
 
-        mm.cc_filter(f'name={hostname}')
-        mm.cc_send(cmd_src)
+        self.mm.cc_filter(f'name={hostname}')
+        self.mm.cc_send(cmd_src)
 
         # wait for file to be sent via cc
-        last_cmd = utils.mm_last_command(mm)
-        utils.mm_wait_for_cmd(mm, last_cmd['id'])
+        last_cmd = utils.mm_last_command(self.mm)
+        utils.mm_wait_for_cmd(self.mm, last_cmd['id'])
+        self.mm.clear_cc_filter()
 
         os.remove(cmd_src)
 

src/python/phenix_apps/apps/scorch/mm/README.md

@@ -7,45 +7,48 @@ exe:  phenix-scorch-component-mm
 
 ## Metadata Options
 
-```
+```yaml
 metadata:
+  # Commands (types) to run for a particular stage (configure, start, stop, cleanup)
   configure:
-  - type: start_capture
-    capture:
-      bridge: phenix
-      filename: capture.pcap # will be auto generated as <bridge>-<ts>.pcap if not provided
-      filter: port 80 # typical BPF filter expression
-      snaplen: null
-  - type: stop_capture
-    capture:
-      bridge: phenix
-      convert: true # convert to JSON (for parsing into Elastic, for example) (default is false)
-  start: [] # same array of keys as above
-  stop: [] # same array of keys as above
-  cleanup: [] # same array of keys as above
-  vms:
-  - hostname: <string>
-    configure:
-    - type: start # can be start, stop, connect, disconnect, start_capture, stop_capture
-    - type: stop
-    - type: connect # can also be used to move an already connected interface
-      connect:
-        interface: 0 # index of interface
-        vlan: FOO
-        bridge: phenix # will use the same bridge previously connected to (if moving) if not provided
-    - type: disconnect
-      disconnect:
-        interface: 0 # index of interface
     - type: start_capture
       capture:
-        interface: 0
-        filename: capture.pcap # will be auto generated as <host>-<iface>-<ts>.pcap if not provided
+        bridge: phenix
+        filename: capture.pcap # will be auto generated as <bridge>-<ts>.pcap if not provided
         filter: port 80 # typical BPF filter expression
         snaplen: null
-    - type: stop_capture # will stop captures on all interfaces (minimega limitation)
+    - type: stop_capture
       capture:
+        bridge: phenix
         convert: true # convert to JSON (for parsing into Elastic, for example) (default is false)
-    start: [] # same array of keys as above
-    stop: [] # same array of keys as above
-    cleanup: [] # same array of keys as above
-```
+  start: [] # same array of keys as above
+  stop: [] # same array of keys as above
+  cleanup: [] # same array of keys as above
+
+  # Commands (types) to run for specific VMs, for a particular stage
+  vms:
+    - hostname: <string>
+      configure:
+      - type: start # can be start, stop, connect, disconnect, start_capture, stop_capture
+      - type: stop
+      - type: connect # can also be used to move an already connected interface
+        connect:
+          interface: 0 # index of interface
+          vlan: FOO
+          bridge: phenix # will use the same bridge previously connected to (if moving) if not provided
+      - type: disconnect
+        disconnect:
+          interface: 0 # index of interface
+      - type: start_capture
+        capture:
+          interface: 0
+          filename: capture.pcap # will be auto generated as <host>-<iface>-<ts>.pcap if not provided
+          filter: port 80 # typical BPF filter expression
+          snaplen: null
+      - type: stop_capture # will stop captures on all interfaces (minimega limitation)
+        capture:
+          convert: true # convert to JSON (for parsing into Elastic, for example) (default is false)
+      start: [] # same array of keys as above
+      stop: [] # same array of keys as above
+      cleanup: [] # same array of keys as above
+```

src/python/phenix_apps/apps/scorch/mm/mm.py

@@ -14,24 +14,19 @@ def __init__(self):
 
         self.execute_stage()
 
-
     def configure(self):
         self.__run('configure')
 
-
     def start(self):
         self.__run('start')
 
-
     def stop(self):
         self.__run('stop')
 
-
     def cleanup(self):
         self.__run('cleanup')
 
-
-    def __run(self, stage):
+    def __run(self, stage: str) -> None:
         mm = self.mm_init()
 
         commands = self.metadata.get(stage, [])
@@ -83,13 +78,13 @@ def __run(self, stage):
                 cap = cmd.get('capture', None)
 
                 if not cap:
-                    self.eprint(f'no bridge capture details provided')
+                    self.eprint('no bridge capture details provided')
                     sys.exit(1)
 
                 bridge = cap.get('bridge', None)
 
                 if not bridge:
-                    self.eprint(f'bridge to stop capture traffic on not provided')
+                    self.eprint('bridge to stop capture traffic on not provided')
                     sys.exit(1)
                 try:
                     self.print(f'stopping pcap capture on bridge {bridge}')
@@ -132,6 +127,8 @@ def __run(self, stage):
                 except Exception as ex:
                     self.eprint(f'unable to stop pcap capture on bridge {bridge}: {ex}')
                     sys.exit(1)
+            else:
+                self.eprint(f"Unknown command type '{cmd.type}'")
 
         vms = self.metadata.get('vms', [])
 
@@ -285,6 +282,8 @@ def __run(self, stage):
                     except Exception as ex:
                         self.eprint(f'unable to stop pcap capture(s) on vm {vm.hostname}: {ex}')
                         sys.exit(1)
+                else:
+                    self.eprint(f"Unknown command type for VM '{vm.hostname}': {cmd.type}")
 
 
 def main():