Merge ~liaou3/checkbox-iiotg/+git/checkbox-provider-intliotg:refactor_tsn_timesync into ~checkbox-dev/checkbox-iiotg/+git/checkbox-provider-intliotg:master

[Vincent Liao]

Refactor TSN 802.1as-2011

I refactor TSN testing from shell script to python.

submissions:
https://certification.canonical.com/hardware/202401-33387/submission/364700/
https://certification.canonical.com/hardware/202401-33387/submission/364721/

[Rick Wu (rickwu4444)]

Hi Vincent, Please see my inline comment.

review: Needs Information

[StanleyHuang (stanley31)]

I have some suggestions in inline comments and one questions as following.

- why we need to run clear_qdisc_settings(interface) function in the beginning of each tests?

review: Needs Fixing

[Vincent Liao (liaou3)]

@Rick

The reason why I use `/usr/share/doc/linuxptp/configs/automotive-slave.cfg` as default instead of `"$SNAP"/usr/share/doc/linuxptp/configs/automotive-slave.cfg` is we are not sure if the user is running this script with checkbox.
If yes, of course it works.
If not, it is better if we use `/usr/share/doc/linuxptp/configs/automotive-slave.cfg` since it is the defaule config for linuxptp.

[Vincent Liao (liaou3)]

> @Rick
>
> The reason why I use `/usr/share/doc/linuxptp/configs/automotive-slave.cfg` as
> default instead of `"$SNAP"/usr/share/doc/linuxptp/configs/automotive-
> slave.cfg` is we are not sure if the user is running this script with
> checkbox.
> If yes, of course it works.
> If not, it is better if we use `/usr/share/doc/linuxptp/configs/automotive-
> slave.cfg` since it is the defaule config for linuxptp.

And I also reckon it is not a good idea to use `environment variable` in the python script. We should use arg parse instead of depending on environment variable.

[Rick Wu (rickwu4444)]

LGTM

review: Approve

[StanleyHuang (stanley31)]

LGTM

review: Approve

diff --git a/bin/tsn.py b/bin/tsn.py
new file mode 100755
index 0000000..c85e686
--- /dev/null
+++ b/bin/tsn.py
@@ -0,0 +1,550 @@
+#!/usr/bin/python3
+
+import argparse
+import subprocess
+import shlex
+from threading import Event
+from typing import List
+from contextlib import contextmanager
+
+
+def clear_qdisc_settings(interface: str) -> None:
+    """Clear the previous qdisc settings.
+
+    This function clears the previous qdisc settings by running the tc
+    command with the 'qdisc del' option. It may return an error if there
+    is no previous settings.
+    This will get errors if there is no previous settings.
+
+    Args:
+        interface (str): The name of the network interface.
+
+    Returns:
+        None
+    """
+    # Build the tc command to delete the root qdisc settings
+    cmd = "tc qdisc del dev {} root".format(interface)
+
+    # Run the tc command with shell=True and a timeout of 1 second
+    subprocess.run(cmd, shell=True, timeout=1)
+
+
+@contextmanager
+def clear_qdisc_settings_before_and_after(interface: str):
+    """Clear the previous qdisc settings.
+
+    This context manager clears the previous qdisc settings by running the
+    tc command with the 'qdisc del' option. It may return an error if there
+    is no previous settings.
+
+    Args:
+        interface (str): The name of the network interface.
+
+    Yields:
+        None
+
+    Raises:
+        subprocess.CalledProcessError: If the tc command fails to delete
+        the root qdisc settings.
+    """
+
+    # Run the tc command to delete the root qdisc settings
+    try:
+        # Clear qdisc settings before the function call
+        clear_qdisc_settings(interface)
+        yield
+    finally:
+        # Clear qdisc settings after the function call
+        clear_qdisc_settings(interface)
+
+
+def clear_qdisc_settings_before_and_after_decorator(func):
+    """
+    Decorator that clears the qdisc settings before and after calling
+    the decorated function.
+
+    Args:
+        func (Callable): The function to be decorated.
+
+    Returns:
+        Callable: The decorated function.
+
+    This decorator wraps the given function with a context manager that
+    clears the qdisc settings before and after the function call.
+    It ensures that the qdisc settings are cleared even if an
+    exception occurs during the function execution.
+
+    Example usage:
+        @clear_qdisc_settings_before_and_after_decorator
+        def my_function(interface, *args, **kwargs):
+            # Function logic here
+
+        my_function("eth0")  # The qdisc settings will be cleared before
+        and after the function call
+    """
+
+    def wrapper(interface, *args, **kwargs):
+        """
+        Wrapper function that clears the qdisc settings before and
+        after calling the decorated function.
+
+        Args:
+            interface (str): The interface to set the clock on.
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
+
+        This function wraps the given function with a context manager that
+        clears the qdisc settings before and after the function call.
+        It ensures that the qdisc settings are cleared even if an exception
+        occurs during the function execution.
+        """
+        with clear_qdisc_settings_before_and_after(interface):
+            # Call the decorated function with the given arguments
+            # and keyword arguments
+            func(interface, *args, **kwargs)
+
+    return wrapper
+
+
+def ptp4l(interface: str, cfg: str, timeout: int = 0) -> subprocess.Popen:
+    """Run ptp4l command to sync physical hardware clock between systems.
+
+    Args:
+        interface (str): The interface to set the clock on.
+        cfg (str): The path to the configuration file.
+        timeout (int): The time to wait for the command to complete, \
+            in seconds.
+
+    Returns:
+        subprocess.Popen: A process object representing \
+        the running ptp4l command.
+    """
+    # Build the ptp4l command with the provided parameters.
+    cmd = "timeout {} ptp4l -i {} -f {} -m".format(
+        timeout,
+        interface,
+        cfg,
+    )
+
+    # Run the ptp4l command with the provided parameters.
+    # The command is run with stdout and stderr redirected to pipes.
+    # Text mode is enabled to allow access to the output as text.
+    process = subprocess.Popen(
+        shlex.split(cmd),
+        stdout=subprocess.PIPE,  # Redirect stdout to a pipe.
+        stderr=subprocess.PIPE,  # Redirect stderr to a pipe.
+        text=True,  # Enable text mode, so output can be accessed as text.
+    )
+
+    # Return the process object representing the running ptp4l command.
+    return process
+
+
+def phc2sys(interface: str, timeout: int = 60) -> subprocess.Popen:
+    """Run phc2sys command to sync system clock to physical hardware clock.
+
+    Args:
+        interface (str): The network interface to sync.
+        timeout (int): The time to wait for the command to complete,
+        in seconds. Defaults to 60 seconds.
+
+    Returns:
+        subprocess.Popen: A process object representing the
+        running phc2sys command.
+    """
+    # Build the phc2sys command with the provided parameters.
+    # The command uses the timeout utility to limit the execution time.
+    # phc2sys is used to sync the system clock to the physical hardware clock.
+    # The -s specifies the interface to sync.
+    # The -O 0 flag sets the offset between system clock
+    # and physical hardware clock to 0.
+    # The -c specify the slave clock source.
+    # The -w flag wait for ptp4l.
+    # The -m flag print the messages.
+    # The --step_threshold=1 flag sets the step threshold to 1.
+    # The --transportSpecific=1 the transport specific field. [0-255]
+    cmd = (
+        "timeout {} phc2sys -s {} "
+        "-O 0 -c CLOCK_REALTIME -w -m "
+        "--step_threshold=1 --transportSpecific=1"
+    ).format(timeout, interface)
+
+    # Run the phc2sys command with the provided parameters.
+    # The command is run with stdout and stderr redirected to pipes.
+    # Text mode is enabled to allow access to the output as text.
+    process = subprocess.Popen(
+        shlex.split(cmd),
+        stdout=subprocess.PIPE,  # Redirect stdout to a pipe.
+        stderr=subprocess.PIPE,  # Redirect stderr to a pipe.
+        text=True,  # Enable text mode, so output can be accessed as text.
+    )
+
+    # Return the process object representing the running phc2sys command.
+    return process
+
+
+def server_mode(
+    interfaces: List,
+    cfg: str = "/usr/share/doc/linuxptp/configs/automotive-master.cfg",
+) -> None:
+    """Run ptp4l as master in every port.
+
+    Args:
+        interfaces (List): List of network interfaces.
+        cfg (str, optional): Path to the configuration file.
+            Defaults to
+            "/usr/share/doc/linuxptp/configs/automotive-master.cfg".
+
+    This function runs ptp4l as master in every port specified
+    in the interfaces list.
+    It terminates all running ptp4l processes on KeyboardInterrupt.
+    """
+
+    # List to store the process objects
+    processes = []
+
+    # Iterate over each interface and run ptp4l as master
+    for interface in interfaces:
+        # Clear qdisc settings for the interface
+        clear_qdisc_settings(interface=interface)
+
+        # Run ptp4l as master with the provided interface and configuration
+        process = ptp4l(interface=interface, cfg=cfg)
+
+        # Add the process object to the list
+        processes.append(process)
+
+        # Print message about the running ptp4l process
+        print("Start running ptp4l on {} as master".format(interface))
+
+    # Print message to press ctrl + c to end this
+    print("Press ctrl + c to end this.")
+
+    try:
+        # Wait for KeyboardInterrupt
+        Event().wait()
+    except KeyboardInterrupt:
+        # Terminate all running ptp4l processes
+        for process in processes:
+            process.terminate()
+
+        # Print message about terminating all ptp4l processes
+        print("Terminated all ptp4l process")
+
+    # Return None
+    return
+
+
+@clear_qdisc_settings_before_and_after_decorator
+def time_sync_ptp4l(
+    interface: str,
+    cfg: str = "/usr/share/doc/linuxptp/configs/automotive-slave.cfg",
+    timeout: int = 60,
+) -> None:
+    """
+    Test ptp4l by running it as a subprocess and checking its output.
+
+    Args:
+        interface (str): The network interface to run ptp4l on.
+        cfg (str, optional): The path to the ptp4l configuration file.
+            Defaults to "/usr/share/doc/linuxptp/configs/automotive-slave.cfg".
+        timeout (int, optional): The maximum time to wait for ptp4l to run.
+            Defaults to 60 seconds.
+
+    Raises:
+        SystemExit: If ptp4l encounters an error or the master offset is not
+        between -100 and 100.
+
+    Prints:
+        Standard Output (stdout): The output of ptp4l.
+        Standard Error (stderr): The error output of ptp4l, if any.
+        [PASS] Masteroffset is between -100 to 100: If the master offset is
+            between -100 and 100.
+        [FAIL] Masteroffset is not between -100 to 100: If the master offset
+            is not between -100 and 100.
+    """
+
+    # Run ptp4l as a subprocess and get its output
+    process = ptp4l(interface=interface, cfg=cfg, timeout=timeout)
+    stdout, stderr = process.communicate()
+
+    # Print the output of ptp4l
+    print("Standard Output (stdout):")
+    print(stdout)
+    print("Standard Error (stderr):")
+    print(stderr)
+
+    # If ptp4l encountered an error, raise a SystemExit exception
+    if stderr:
+        raise SystemExit(
+            "[Error] Catch error while running ptp4l on {}".format(interface)
+        )
+
+    # Check the last 10 seconds of ptp4l output
+    lines = stdout.splitlines()
+    for line in lines[-10:]:
+        offset = int(line.split()[3])
+        if not -100 < offset < 100:
+            raise SystemExit("[FAIL] Masteroffset is not between -100 to 100")
+
+    # If the master offset is between -100 and 100, print a success message
+    print("[PASS] Masteroffset is between -100 to 100")
+
+
+@clear_qdisc_settings_before_and_after_decorator
+def time_sync_phc2sys(
+    interface: str,
+    cfg: str = "/usr/share/doc/linuxptp/configs/automotive-slave.cfg",
+    timeout: int = 60,
+) -> None:
+    """
+    Test phc2sys by running it as a subprocess and checking its output.
+
+    Args:
+        interface (str): The network interface to run phc2sys on.
+        cfg (str, optional): The path to the phc2sys configuration file.
+            Defaults to "/usr/share/doc/linuxptp/configs/automotive-slave.cfg".
+        timeout (int, optional): The maximum time to wait for phc2sys to run.
+            Defaults to 60 seconds.
+
+    Raises:
+        SystemExit: If phc2sys encounters an error or the master offset is not
+            between -100 and 100, or the state is not equal to "s2" for the
+            last 10 seconds, or the path delay is not equal to 0.
+
+    Prints:
+        Standard Output (stdout): The output of phc2sys.
+        Standard Error (stderr): The error output of phc2sys, if any.
+        [PASS] Syncing system time to physical hardware clock successfully: If
+            phc2sys syncs the system time to physical hardware clock
+            successfully.
+    """
+
+    # Run ptp4l as a subprocess and get its output
+    ptp4l(interface=interface, cfg=cfg, timeout=timeout)
+
+    # Run phc2sys as a subprocess and get its output
+    process = phc2sys(interface=interface, timeout=timeout)
+    stdout, stderr = process.communicate()
+
+    # Print the output of phc2sys
+    print("Standard Output (stdout):")
+    print(stdout)
+    print("Standard Error (stderr):")
+    print(stderr)
+
+    # If phc2sys encountered an error, raise a SystemExit exception
+    if stderr:
+        print(f"[Error] Catch error while running ptp4l on {interface}")
+        raise SystemExit(
+            "[Error] Catch error while running ptp4l on {}".format(interface)
+        )
+
+    # Check the last 10 seconds of phc2sys output
+    lines = stdout.splitlines()
+    for line in lines[-10:]:
+        offset = int(line.split()[4])
+        state = line.split()[5]
+        delay = int(line.split()[9])
+
+        # If the master offset is not between -100 and 100,
+        # raise a SystemExit exception
+        if not -100 < offset < 100:
+            print("[FAIL] phc offset is not between -100 to 100")
+            raise SystemExit(1)
+
+        # If the state is not equal to "s2" for the last 10 seconds,
+        # raise a SystemExit exception
+        if state != "s2":
+            raise SystemExit("[FAIL] state is not equal to s2 "
+                             "for the last 10 seconds\n"
+                             "s0: unsynced\n"
+                             "s1: syncing\n"
+                             "s2: synced")
+
+        # If the path delay is not equal to 0 for the last 10 seconds,
+        # raise a SystemExit exception
+        if delay != 0:
+            raise SystemExit("[FAIL] path delay is not equal to 0\n"
+                             "path delay should be 0 if using hardware "
+                             "cross timestamping")
+
+    # If phc2sys syncs the system time to physical hardware clock successfully,
+    # print a success message
+    print("[PASS] Syncing system time to physical hardware clock successfully")
+
+
+@clear_qdisc_settings_before_and_after_decorator
+def time_based_shaper(interface: str, timeout: int = 10) -> None:
+    """
+    Setup a time-based shaper on the specified interface.
+
+    Args:
+        interface (str): The interface to set the shaper on.
+        timeout (int): The timeout for the shaper in seconds.
+
+    Raises:
+        SystemExit: If there are more than 5% packets not within the required
+            time interval.
+    """
+
+    # Add mqprio qdisc with four traffic classes
+    cmd = (
+        "tc qdisc add dev {} handle 8001: parent root mqprio num_tc 4 "
+        "map 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 queues 1@0 1@1 1@2 1@3 hw 0"
+    ).format(interface)
+    subprocess.run(cmd, shell=True, timeout=1)
+
+    # Replace parent qdisc with etf offload
+    cmd = (
+        "tc qdisc replace dev {} parent 8001:4 etf offload clockid CLOCK_TAI "
+        "delta 500000"
+    ).format(interface)
+    subprocess.run(cmd, shell=True, timeout=1)
+
+    # Show the current qdisc settings
+    cmd = "tc qdisc show dev {}".format(interface)
+    subprocess.run(cmd, shell=True, timeout=1)
+
+    # Run udp_tai with specified parameters
+    cmd = "udp_tai -c 3 -i {} -P 1000000 -p 90 -d 600000".format(interface)
+    process_udp_tai = subprocess.Popen(
+        shlex.split(cmd), stdout=subprocess.PIPE, text=True
+    )
+
+    # Capture packets with tcpdump and
+    # check that they are within the required time interval
+    cmd = (
+        "tcpdump -G {} -Q out -ttt -ni {} --time-stamp-precision=nano "
+        "-j adapter_unsynced port 7788 -c {}".format(
+            timeout, interface, timeout * 1000
+        )
+    )
+    process = subprocess.Popen(
+        shlex.split(cmd), stdout=subprocess.PIPE, text=True
+    )
+    try:
+        stdout, stderr = process.communicate(timeout=timeout * 2)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        raise SystemExit("Reach timeout {}".format(timeout * 2))
+    finally:
+        process_udp_tai.kill()
+
+    if stdout is None or stderr is not None:
+        raise SystemExit("No output from tcpdump!")
+
+    # Print the output of tcpdump
+    print("Standard Output (stdout):")
+    print(stdout)
+    print("Standard Error (stderr):")
+    print(stderr)
+
+    lines = stdout.splitlines()
+    cnt = 0
+    for line in lines:
+        try:
+            time = int(line.split()[0].split(".")[1])
+        except (IndexError, ValueError):
+            raise SystemExit(
+                "[ERROR] Cannot find the time in the line: {}".format(line)
+            )
+        if not 999500 < time < 1000500:
+            cnt += 1
+
+    # If there are more than 5% packets not within the required time interval,
+    # raise a SystemExit exception
+    if cnt > timeout * 1000 * 0.05:
+        raise SystemExit(
+            "[FAIL] There are {}/{} (more than 5%) packets not "
+            "within the required time interval (999500 - 1000500)".format(
+                cnt, timeout * 1000
+            )
+        )
+
+    print(
+        "[PASS] There are {}/{} packets (less than 5%) within "
+        "the required time interval (999500 - 1000500)".format(
+            cnt, timeout * 1000
+        )
+    )
+
+
+def main():
+    """
+    Main function to parse command line arguments and perform the
+    specified testing item or server_mode.
+    """
+    # Create ArgumentParser object
+    parser = argparse.ArgumentParser(
+        prog="TSN Testing Tool",
+        description="This is a tool to help you perform the TSN testing",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    # Add arguments
+    parser.add_argument(
+        "--run",
+        action="store",
+        choices=["server", "ptp4l", "phc2sys", "time_based_shaper"],
+        help="Run a testing item or server_mode",
+    )
+    parser.add_argument(
+        "--interfaces", "-i", nargs="+", help="TSN ethernet interface"
+    )
+    parser.add_argument(
+        "--timeout",
+        "-t",
+        action="store",
+        type=int,
+        default=60,
+        help="Timeout for the testing item",
+    )
+    parser.add_argument(
+        "--master-config",
+        action="store",
+        type=str,
+        default="/usr/share/doc/linuxptp/configs/automotive-master.cfg",
+        help="gPTP config file for master",
+    )
+    parser.add_argument(
+        "--client-config",
+        action="store",
+        type=str,
+        default="/usr/share/doc/linuxptp/configs/automotive-slave.cfg",
+        help="gPTP config file for client",
+    )
+
+    # Parse command line arguments
+    args = parser.parse_args()
+
+    # Perform the specified testing item or server_mode
+    if args.run == "server":
+        # Run server_mode
+        server_mode(args.interfaces, cfg=args.master_config)
+        return
+    elif len(args.interfaces) != 1:
+        # Exit if interfaces is not a single element
+        raise SystemExit("We only need one interface for testing!")
+
+    if args.run == "ptp4l":
+        # Time sync with ptp4l
+        time_sync_ptp4l(
+            args.interfaces[0],
+            cfg=args.client_config,
+            timeout=args.timeout,
+        )
+    elif args.run == "phc2sys":
+        # Time sync with phc2sys
+        time_sync_phc2sys(
+            args.interfaces[0],
+            cfg=args.client_config,
+            timeout=args.timeout,
+        )
+    elif args.run == "time_based_shaper":
+        # Time based shaper
+        time_based_shaper(interface=args.interfaces[0], timeout=args.timeout)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/bin/tsn_time_based_shaper.sh b/bin/tsn_time_based_shaper.sh
deleted file mode 100755
index 6106700..0000000
--- a/bin/tsn_time_based_shaper.sh
+++ /dev/null
@@ -1,49 +0,0 @@
-#!/bin/bash
-
-set -e
-
-timeout=$1
-eth_interface=$2
-server_user=$3
-server_ip=$4
-server_pwd=$5
-server_eth_interface=$6
-
-echo "## Clearing previous queue discipline configuration..."
-echo "## You will get errors if there's no previous configuration, but you could ignore it."
-tc qdisc del dev "$eth_interface" root || true
-echo ""
-
-echo "## Setting time schedule..."
-tc qdisc add dev "$eth_interface" handle 8001: parent root mqprio num_tc 4 map 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 queues 1@0 1@1 1@2 1@3 hw 0
-tc qdisc replace dev "$eth_interface" parent 8001:4 etf offload clockid CLOCK_TAI delta 500000
-echo ""
-
-echo "## Showing qdisc settings..."
-tc qdisc show dev "$eth_interface"
-echo ""
-
-echo "## Start sending and receiving udp packets..."
-out=$(mktemp)
-timeout "$timeout" udp_tai -c 3 -i "$eth_interface" -P 1000000 -p 90 -d 600000 > /dev/null &
-(sshpass -p "u" ssh -o StrictHostKeyChecking=no "$server_user"@"$server_ip" "echo $server_pwd | sudo -S tcpdump -G $timeout -Q in -ttt -ni $server_eth_interface --time-stamp-precision=nano -j adapter_unsynced port 7788 -c 20000") | tee "$out"
-
-echo "## Checking result..."
-lines=$(tail -n 10000 "$out")
-count=0
-while read -r line
-do
-    interval=$(echo "$line" | awk '{print $1}' | awk -F "." '{print $2}')
-    if [ "$interval" -gt 1000500 ] || [ "$interval" -lt 999500 ]; then
-        count=$((count+1))
-    fi
-done <<< "$lines"
-
-echo "In the last 10000 packets there are $count packets are not within 1000000+/-500 ns interval."
-echo "Pass condition: Less than 5% packets not within the required interval"
-if [ $count -lt 500 ]; then
-    echo "PASS"
-else
-    echo "FAIL"
-    exit 1
-fi
diff --git a/units/tsn/jobs.pxu b/units/tsn/jobs.pxu
index 92f6082..cd98d21 100644
--- a/units/tsn/jobs.pxu
+++ b/units/tsn/jobs.pxu
@@ -27,31 +27,6 @@ command:
     exit "$exit_code"
 
 unit: job
-id: tsn/testing-snap-install-check
-category_id: tsn
-_summary: TSN testing snap installation check
-_description: 
-    To check if the TSN related snap is installed
-     - linuxptp-rt
-     - ethtool-rt
-     - iproute2-rt
-depends: tsn/tsn-detected
-plugin: shell
-command:
-    snap_list="linuxptp-rt ethtool-rt iproute2-rt"
-    exit_code=0
-    for snap in $snap_list; do
-        if ! snap list | grep -q $snap; then
-            echo "ERROR: snap package \"${snap}\" not found!"
-            echo "Try install it with the command below"
-            echo "sudo snap install ${snap} --edge --devmode"
-            echo ""
-            exit_code=1
-        fi
-    done
-    exit $exit_code
-
-unit: job
 category_id: tsn
 id: tsn/tsn-devices
 plugin: resource
@@ -145,146 +120,62 @@ unit: template
 template-resource: tsn/tsn-devices
 template-unit: job
 template-engine: jinja2
-id: tsn/ieee802.1as-2011/time-sync-between-two-system-as-client-{{ interface }}
-category_id: tsn
-_summary:
-    Check establish time-sync with another machine as client via {{ interface }}
-_purpose:
-    Use {{ interface }} on the SUT to achieve time sync with the second machine as client
-depends:
-    tsn/tsn-detected
-    tsn/testing-snap-install-check
-plugin: shell
-user: root
-environ:
-    TSN_SERVER_IP
-    TSN_SERVER_USER
-    TSN_SERVER_PWD
-    TSN_SERVER_INTERFACE
-    TSN_MAX_MASTER_OFFSET
-    TSN_SYNC_TIME
-command:
-    set -e
-    out=$(mktemp)
-    tsn_time_sync.sh ${TSN_SYNC_TIME:-60} client {{ interface }} "$TSN_SERVER_USER" "$TSN_SERVER_IP" "$TSN_SERVER_PWD" "$TSN_SERVER_INTERFACE" | tee "$out"
-    echo ""
-    lines=$(tail -n 10 "$out")
-    while read -r line
-    do
-        offset=$(echo "$line" | grep -o 'master offset\s*-\?[0-9]\+ s' | awk '{print $3}')
-        if [ "$offset" -gt "${TSN_MAX_MASTER_OFFSET:-100}" ] || [ "$offset" -lt -"${TSN_MAX_MASTER_OFFSET:-100}" ]; then
-            echo "FAIL: master offset is not within -"${TSN_MAX_MASTER_OFFSET:-100}" to "${TSN_MAX_MASTER_OFFSET:-100}" for the last 10 seconds."
-            exit 1
-        fi
-    done <<< "$lines"
-    echo "PASS: master offset is within -"${TSN_MAX_MASTER_OFFSET:-100}" to "${TSN_MAX_MASTER_OFFSET:-100}" for the last 10 seconds."
-
-unit: template
-template-resource: tsn/tsn-devices
-template-unit: job
-template-engine: jinja2
-id: tsn/ieee802.1as-2011/time-sync-between-two-system-as-master-{{ interface }}
-category_id: tsn
-_summary:
-    Check establish time-sync with another machine as master via {{ interface }}
-_purpose:
-    Use {{ interface }} on the SUT to achieve time sync with the second machine as master
-depends:
-    tsn/tsn-detected
-plugin: shell
-user: root
-environ:
-    TSN_SERVER_IP
-    TSN_SERVER_USER
-    TSN_SERVER_PWD
-    TSN_SERVER_INTERFACE
-    TSN_MAX_MASTER_OFFSET
-    TSN_SYNC_TIME
-command:
-    set -e
-    out=$(mktemp)
-    tsn_time_sync.sh ${TSN_SYNC_TIME:-60} master {{ interface }} "$TSN_SERVER_USER" "$TSN_SERVER_IP" "$TSN_SERVER_PWD" "$TSN_SERVER_INTERFACE" | tee "$out"
-    echo ""
-    lines=$(tail -n 10 "$out")
-    while read -r line
-    do
-        offset=$(echo "$line" | grep -o 'master offset\s*-\?[0-9]\+ s' | awk '{print $3}')
-        if [ "$offset" -gt "${TSN_MAX_MASTER_OFFSET:-100}" ] || [ "$offset" -lt -"${TSN_MAX_MASTER_OFFSET:-100}" ]; then
-            echo "FAIL: master offset is not within -"${TSN_MAX_MASTER_OFFSET:-100}" to "${TSN_MAX_MASTER_OFFSET:-100}" for the last 10 seconds."
-            exit 1
-        fi
-    done <<< "$lines"
-    echo "PASS: master offset is within -"${TSN_MAX_MASTER_OFFSET:-100}" to "${TSN_MAX_MASTER_OFFSET:-100}" for the last 10 seconds."
-
-unit: template
-template-resource: tsn/tsn-devices
-template-unit: job
-template-engine: jinja2
-id: tsn/ieee802.1as-2011/time-sync-system-clock-with-PHC-as-client-{{ interface }}
+template-id: tsn/ieee802-1as-2011/ptp4l-interfaces
+_template-summary: Time sync to another machine via ethernet interfaces
+id: tsn/ieee802-1as-2011/ptp4l-{{ interface }}
 category_id: tsn
 _summary:
-    System time sync with PTP hardware clock as client
+    Time sync to another machine as client via {{ interface }}
 depends:
     tsn/tsn-detected
-    tsn/ieee802.1as-2011/time-sync-between-two-system-as-client-{{ interface }}
 plugin: shell
 user: root
-_purpose:
-    To check if the system can sync time between system clock and PTP hardware clock as client via {{ interface }}
 environ:
-    TSN_SERVER_IP
-    TSN_SERVER_USER
-    TSN_SERVER_PWD
-    TSN_SERVER_INTERFACE
-    TSN_SYNC_TIME
+    SNAP
+    PTP4L_TESTING_TIME
+    PTP_CLIENT_CFG
 command:
-    tsn_phc2sys.sh ${TSN_SYNC_TIME:-60} client {{ interface }} "$TSN_SERVER_USER" "$TSN_SERVER_IP" "$TSN_SERVER_PWD" "$TSN_SERVER_INTERFACE"
+    tsn.py --run ptp4l -i {{ interface }} -t ${PTP4L_TESTING_TIME:-60} --client-config ${PTP_CLIENT_CFG:-"$SNAP"/usr/share/doc/linuxptp/configs/automotive-slave.cfg}
 
 unit: template
 template-resource: tsn/tsn-devices
 template-unit: job
 template-engine: jinja2
-id: tsn/ieee802.1as-2011/time-sync-system-clock-with-PHC-as-master-{{ interface }}
+template-id: tsn/ieee802-1as-2011/phc2sys-interfaces
+id: tsn/ieee802-1as-2011/phc2sys-{{ interface }}
 category_id: tsn
 _summary:
-    System time sync with PTP hardware clock as master
+    System time sync to PTP hardware clock on {{ interface }}
 depends:
     tsn/tsn-detected
-    tsn/ieee802.1as-2011/time-sync-between-two-system-as-master-{{ interface }}
+    tsn/ieee802-1as-2011/ptp4l-{{ interface }}
 plugin: shell
 user: root
-_purpose:
-    To check if the system can sync time between system clock and PTP hardware clock as master via {{ interface }}
 environ:
-    TSN_SERVER_IP
-    TSN_SERVER_USER
-    TSN_SERVER_PWD
-    TSN_SERVER_INTERFACE
-    TSN_SYNC_TIME
+    SNAP
+    PHC2SYS_TESTING_TIME
+    PTP_CLIENT_CFG
 command:
-    tsn_phc2sys.sh ${TSN_SYNC_TIME:-60} master {{ interface }} "$TSN_SERVER_USER" "$TSN_SERVER_IP" "$TSN_SERVER_PWD" "$TSN_SERVER_INTERFACE"
+    tsn.py --run phc2sys -i {{ interface }} -t ${PHC2SYS_TESTING_TIME:-60} --client-config ${PTP_CLIENT_CFG:-"$SNAP"/usr/share/doc/linuxptp/configs/automotive-slave.cfg}
 
 unit: template
 template-resource: tsn/tsn-devices
 template-unit: job
 template-engine: jinja2
+template-id: tsn/time-based-shaping/udp-packet-time-check-interfaces
 id: tsn/time-based-shaping/udp-packet-time-check-{{ interface }}
 category_id: tsn
 _summary: UDP packet time intervals check
 depends:
     tsn/tsn-detected
-    tsn/testing-snap-install-check
 plugin: shell
 user: root
 _purpose:
-    To check if the system can transmit udp packet precisely at 1 ms intervals
+    To check if the system can send udp packet precisely at 1 ms intervals
 environ:
-    TSN_SERVER_IP
-    TSN_SERVER_USER
-    TSN_SERVER_PWD
-    TSN_SERVER_INTERFACE
+    TIME_BASED_SHAPER_TESTING_TIME
 command:
-    tsn_time_based_shaper.sh 30 {{ interface }} "$TSN_SERVER_USER" "$TSN_SERVER_IP" "$TSN_SERVER_PWD" "$TSN_SERVER_INTERFACE"
+    tsn.py --run time_based_shaper --interface {{ interface }} --timeout ${TIME_BASED_SHAPER_TESTING_TIME:-10}
 
 unit: template
 template-resource: tsn/tsn-devices
diff --git a/units/tsn/test-plan.pxu b/units/tsn/test-plan.pxu
index c5cc31d..97e132c 100644
--- a/units/tsn/test-plan.pxu
+++ b/units/tsn/test-plan.pxu
@@ -29,13 +29,13 @@ include:
     tsn/test-env-setup-for-.*
     tsn/testing-snap-install-check
 nested_part:
-    tsn-ieee802.1as-2011
+    tsn/ieee802-1as-2011
     tsn-ieee802.1qav
     tsn-ieee802.1qbu
     tsn-time-based-shaping
     tsn-ieee802.1qbv
 
-id: tsn-ieee802.1as-2011
+id: tsn/ieee802-1as-2011
 _name: Time Sensitive Networking Test Plan for IEEE 802.1AS-2011
 _description:
     This testplan is to check if it could follow IEEE 802.1AS-2011.
@@ -46,11 +46,8 @@ unit: test plan
 bootstrap_include:
     tsn/tsn-devices
 include:
-    tsn/testing-snap-install-check
-    tsn/ieee802.1as-2011/time-sync-between-two-system-as-client-.*
-    tsn/ieee802.1as-2011/time-sync-between-two-system-as-master-.*
-    tsn/ieee802.1as-2011/time-sync-system-clock-with-PHC-as-client-.*
-    tsn/ieee802.1as-2011/time-sync-system-clock-with-PHC-as-master-.*    
+    tsn/ieee802-1as-2011/ptp4l-interfaces
+    tsn/ieee802-1as-2011/phc2sys-interfaces
 
 id: tsn-time-based-shaping
 _name: Time Sensitive Networking Test Plan for Time-Based Shaping
@@ -63,7 +60,7 @@ bootstrap_include:
     tsn/tsn-devices
 include:
     tsn/testing-snap-install-check
-    tsn/time-based-shaping/udp-packet-time-check-.*
+    tsn/time-based-shaping/udp-packet-time-check-interfaces
 
 id: tsn-ieee802.1qav
 _name: Time Sensitive Networking Test Plan for IEEE 802.1Qav