Separate files needing GPL license

+ Keep apache license for now, until this is completed:
  https://wiki.fd.io/view/TSC/Relicensing_Procedure
+ Add utilities for switching license comment blocks.
 - They do not preserve attributes, so executable flag is lost.
+ Move the affected files to GPL/.
 + Update paths so files are executed from the new location.
 + Change the way scripts are started to do not require executable flag.
 + Employ OptionString when constructing longer command lines.
+ Move also PacketVerifier.py and TrafficScriptArg.py
  as they are linked with traffic scripts.
 + That means the two files are outside "resources" package tree now.
 + Added __init__.py files so relative imports work in new package tree.
+ Start traffic scripts as python modules to allow relative imports.
 + Once again needed because they are outside the default PYTHONPATH.

Change-Id: Ieb135629e890adbaf5b79497570f3be25b746f9f
Signed-off-by: Vratko Polak <vrpolak@cisco.com>

4 files changed, 39 insertions, 449 deletions

diff --git a/resources/libraries/python/PacketVerifier.py b/resources/libraries/python/PacketVerifier.py
deleted file mode 100644
index fb2337e49d..0000000000
--- a/resources/libraries/python/PacketVerifier.py
+++ /dev/null
@@ -1,344 +0,0 @@
-# Copyright (c) 2019 Cisco and/or its affiliates.
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at:
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""PacketVerifier module.
-
-  Example. ::
-
-    | >>> from scapy.all import *
-    | >>> from PacketVerifier import *
-    | >>> rxq = RxQueue('eth1')
-    | >>> txq = TxQueue('eth1')
-    | >>> src_mac = "AA:BB:CC:DD:EE:FF"
-    | >>> dst_mac = "52:54:00:ca:5d:0b"
-    | >>> src_ip = "11.11.11.10"
-    | >>> dst_ip = "11.11.11.11"
-    | >>> sent_packets = []
-    | >>> pkt_send = Ether(src=src_mac, dst=dst_mac) /
-    | ... IP(src=src_ip, dst=dst_ip) /
-    | ... ICMP()
-    | >>> sent_packets.append(pkt_send)
-    | >>> txq.send(pkt_send)
-    | >>> pkt_send = Ether(src=src_mac, dst=dst_mac) /
-    | ... ARP(hwsrc=src_mac, psrc=src_ip, hwdst=dst_mac, pdst=dst_ip, op=2)
-    | >>> sent_packets.append(pkt_send)
-    | >>> txq.send(pkt_send)
-    | >>> rxq.recv(100, sent_packets).show()
-    | ###[ Ethernet ]###
-    |   dst       = aa:bb:cc:dd:ee:ff
-    |   src       = 52:54:00:ca:5d:0b
-    |   type      = 0x800
-    | ###[ IP ]###
-    |   version   = 4L
-    |   ihl       = 5L
-    |   tos       = 0x0
-    |   len       = 28
-    |   id        = 43183
-    |   flags     =
-    |   frag      = 0L
-    |   ttl       = 64
-    |   proto     = icmp
-    |   chksum    = 0xa607
-    |   src       = 11.11.11.11
-    |   dst       = 11.11.11.10
-    |   options
-    | ###[ ICMP ]###
-    |   type      = echo-reply
-    |   code      = 0
-    |   chksum    = 0xffff
-    |   id        = 0x0
-    |   seq       = 0x0
-    | ###[ Padding ]###
-    |   load = 'RT\x00\xca]\x0b\xaa\xbb\xcc\xdd\xee\xff\x08\x06\x00\x01\x08\x00'
-
-  Example end.
-"""
-
-import os
-import select
-
-from scapy.all import ETH_P_IP, ETH_P_IPV6, ETH_P_ALL, ETH_P_ARP
-from scapy.config import conf
-from scapy.layers.inet6 import IPv6
-from scapy.layers.l2 import Ether, ARP
-from scapy.packet import Raw
-
-# Enable libpcap's L2listen
-conf.use_pcap = True
-
-__all__ = [
-    u"RxQueue", u"TxQueue", u"Interface", u"create_gratuitous_arp_request",
-    u"auto_pad", u"checksum_equal"
-]
-
-# TODO: http://stackoverflow.com/questions/320232/
-# ensuring-subprocesses-are-dead-on-exiting-python-program
-
-
-class PacketVerifier:
-    """Base class for TX and RX queue objects for packet verifier."""
-    def __init__(self, interface_name):
-        os.system(
-            f"sudo echo 1 > /proc/sys/net/ipv6/conf/{interface_name}/"
-            f"disable_ipv6"
-        )
-        os.system(f"sudo ip link set {interface_name} up promisc on")
-        self._ifname = interface_name
-
-
-def extract_one_packet(buf):
-    """Extract one packet from the incoming buf buffer.
-
-    Takes string as input and looks for first whole packet in it.
-    If it finds one, it returns substring from the buf parameter.
-
-    :param buf: String representation of incoming packet buffer.
-    :type buf: str
-    :returns: String representation of first packet in buf.
-    :rtype: str
-    """
-    pkt_len = 0
-
-    if len(buf) < 60:
-        return None
-
-    try:
-        ether_type = Ether(buf[0:14]).type
-    except AttributeError:
-        raise RuntimeError(f"No EtherType in packet {buf!r}")
-
-    if ether_type == ETH_P_IP:
-        # 14 is Ethernet fame header size.
-        # 4 bytes is just enough to look for length in ip header.
-        # ip total length contains just the IP packet length so add the Ether
-        #     header.
-        pkt_len = Ether(buf[0:14+4]).len + 14
-        if len(buf) < 60:
-            return None
-    elif ether_type == ETH_P_IPV6:
-        if not Ether(buf[0:14+6]).haslayer(IPv6):
-            raise RuntimeError(f"Invalid IPv6 packet {buf!r}")
-        # ... to add to the above, 40 bytes is the length of IPV6 header.
-        #   The ipv6.len only contains length of the payload and not the header
-        pkt_len = Ether(buf)[u"IPv6"].plen + 14 + 40
-        if len(buf) < 60:
-            return None
-    elif ether_type == ETH_P_ARP:
-        pkt = Ether(buf[:20])
-        if not pkt.haslayer(ARP):
-            raise RuntimeError(u"Incomplete ARP packet")
-        # len(eth) + arp(2 hw addr type + 2 proto addr type
-        #                + 1b len + 1b len + 2b operation)
-
-        pkt_len = 14 + 8
-        pkt_len += 2 * pkt.getlayer(ARP).hwlen
-        pkt_len += 2 * pkt.getlayer(ARP).plen
-
-        del pkt
-    elif ether_type == 32821:  # RARP (Reverse ARP)
-        pkt = Ether(buf[:20])
-        pkt.type = ETH_P_ARP  # Change to ARP so it works with scapy
-        pkt = Ether(pkt)
-        if not pkt.haslayer(ARP):
-            pkt.show()
-            raise RuntimeError(u"Incomplete RARP packet")
-
-        # len(eth) + arp(2 hw addr type + 2 proto addr type
-        #                + 1b len + 1b len + 2b operation)
-        pkt_len = 14 + 8
-        pkt_len += 2 * pkt.getlayer(ARP).hwlen
-        pkt_len += 2 * pkt.getlayer(ARP).plen
-
-        del pkt
-    else:
-        raise RuntimeError(f"Unknown protocol {ether_type}")
-
-    if pkt_len < 60:
-        pkt_len = 60
-
-    if len(buf) < pkt_len:
-        return None
-
-    return buf[0:pkt_len]
-
-
-def packet_reader(interface_name, queue):
-    """Sub-process routine that reads packets and puts them to queue.
-
-    This function is meant to be run in separate subprocess and is in tight
-    loop reading raw packets from interface passed as parameter.
-
-    :param interface_name: Name of interface to read packets from.
-    :param queue: Queue in which this function will push incoming packets.
-    :type interface_name: str
-    :type queue: multiprocessing.Queue
-    """
-    sock = conf.L2listen(iface=interface_name, type=ETH_P_ALL)
-
-    while True:
-        pkt = sock.recv(0x7fff)
-        queue.put(pkt)
-
-
-class RxQueue(PacketVerifier):
-    """Receive queue object.
-
-    This object creates raw socket, reads packets from it and provides
-    function to access them.
-
-    :param interface_name: Which interface to bind to.
-    :type interface_name: str
-    """
-    def __init__(self, interface_name):
-        PacketVerifier.__init__(self, interface_name)
-        self._sock = conf.L2listen(iface=interface_name, type=ETH_P_ALL)
-
-    def recv(self, timeout=3, ignore=None, verbose=True):
-        """Read next received packet.
-
-        Returns scapy's Ether() object created from next packet in the queue.
-        Queue is being filled in parallel in subprocess. If no packet
-        arrives in given timeout queue.Empty exception will be risen.
-
-        :param timeout: How many seconds to wait for next packet.
-        :param ignore: List of packets that should be ignored.
-        :param verbose: Used to suppress detailed logging of received packets.
-        :type timeout: int
-        :type ignore: list
-        :type verbose: bool
-
-        :returns: Ether() initialized object from packet data.
-        :rtype: scapy.Ether
-        """
-        ignore_list = list()
-        if ignore is not None:
-            for ig_pkt in ignore:
-                # Auto pad all packets in ignore list
-                ignore_list.append(str(auto_pad(ig_pkt)))
-        while True:
-            rlist, _, _ = select.select([self._sock], [], [], timeout)
-            if self._sock not in rlist:
-                return None
-
-            pkt = self._sock.recv(0x7fff)
-            pkt_pad = str(auto_pad(pkt))
-            print(f"Received packet on {self._ifname} of len {len(pkt)}")
-            if verbose:
-                if hasattr(pkt, u"show2"):
-                    pkt.show2()
-                else:
-                    # Never happens in practice, but Pylint does not know that.
-                    print(f"Unexpected instance: {pkt!r}")
-                print()
-            if pkt_pad in ignore_list:
-                ignore_list.remove(pkt_pad)
-                print(u"Received packet ignored.")
-                continue
-            return pkt
-
-
-class TxQueue(PacketVerifier):
-    """Transmission queue object.
-
-    This object is used to send packets over RAW socket on a interface.
-
-    :param interface_name: Which interface to send packets from.
-    :type interface_name: str
-    """
-    def __init__(self, interface_name):
-        PacketVerifier.__init__(self, interface_name)
-        self._sock = conf.L2socket(iface=interface_name, type=ETH_P_ALL)
-
-    def send(self, pkt, verbose=True):
-        """Send packet out of the bound interface.
-
-        :param pkt: Packet to send.
-        :param verbose: Used to suppress detailed logging of sent packets.
-        :type pkt: string or scapy Packet derivative.
-        :type verbose: bool
-        """
-        pkt = auto_pad(pkt)
-        print(f"Sending packet out of {self._ifname} of len {len(pkt)}")
-        if verbose:
-            pkt.show2()
-            print()
-
-        self._sock.send(pkt)
-
-
-class Interface:
-    """Class for network interfaces. Contains methods for sending and receiving
-     packets."""
-    def __init__(self, if_name):
-        """Initialize the interface class.
-
-        :param if_name: Name of the interface.
-        :type if_name: str
-        """
-        self.if_name = if_name
-        self.sent_packets = []
-        self.rxq = RxQueue(if_name)
-        self.txq = TxQueue(if_name)
-
-    def send_pkt(self, pkt):
-        """Send the provided packet out the interface."""
-        self.sent_packets.append(pkt)
-        self.txq.send(pkt)
-
-    def recv_pkt(self, timeout=3):
-        """Read one packet from the interface's receive queue.
-
-        :param timeout: Timeout value in seconds.
-        :type timeout: int
-        :returns: Ether() initialized object from packet data.
-        :rtype: scapy.Ether
-        """
-        return self.rxq.recv(timeout, self.sent_packets)
-
-
-def create_gratuitous_arp_request(src_mac, src_ip):
-    """Creates scapy representation of gratuitous ARP request."""
-    return (Ether(src=src_mac, dst=u"ff:ff:ff:ff:ff:ff") /
-            ARP(psrc=src_ip, hwsrc=src_mac, pdst=src_ip)
-            )
-
-
-def auto_pad(packet):
-    """Pads zeroes at the end of the packet if the total len < 60 bytes."""
-    # padded = str(packet)
-    if len(packet) < 60:
-        packet[Raw].load += (b"\0" * (60 - len(packet)))
-    return packet
-
-
-def checksum_equal(chksum1, chksum2):
-    """Compares two checksums in one's complement notation.
-
-    Checksums to be compared are calculated as 16 bit one's complement of the
-    one's complement sum of 16 bit words of some buffer.
-    In one's complement notation 0x0000 (positive zero) and 0xFFFF
-    (negative zero) are equivalent.
-
-    :param chksum1: First checksum.
-    :param chksum2: Second checksum.
-    :type chksum1: uint16
-    :type chksum2: uint16
-
-    :returns: True if checksums are equivalent, False otherwise.
-    :rtype: boolean
-    """
-    if chksum1 == 0xFFFF:
-        chksum1 = 0
-    if chksum2 == 0xFFFF:
-        chksum2 = 0
-    return chksum1 == chksum2
diff --git a/resources/libraries/python/TrafficGenerator.py b/resources/libraries/python/TrafficGenerator.py
index 539ced584a..c63dc2d504 100644
--- a/resources/libraries/python/TrafficGenerator.py
+++ b/resources/libraries/python/TrafficGenerator.py
@@ -75,7 +75,7 @@ class TGDropRateSearchImpl(DropRateSearch):
         :param loss_acceptance: Permitted drop ratio or frames count.
         :param loss_acceptance_type: Type of permitted loss.
         :param traffic_profile: Module name as a traffic profile identifier.
-            See resources/traffic_profiles/trex for implemented modules.
+            See GPL/traffic_profiles/trex for implemented modules.
         :param skip_warmup: Start TRex without warmup traffic if true.
         :type rate: float
         :type frame_size: str
@@ -406,12 +406,13 @@ class TrafficGenerator(AbstractMeasurer):
                     )
                     raise RuntimeError(u"Start TRex failed!")
 
-                # Test if TRex starts successfully.
-                cmd = f"sh -c \"{Constants.REMOTE_FW_DIR}/resources/tools/" \
-                    f"trex/trex_server_info.py\""
+                # Test if TRex starts successfuly.
+                command_line = OptionString().add(u"python3")
+                dirname = f"{Constants.REMOTE_FW_DIR}/GPL/tools/trex"
+                command_line.add(f"'{dirname}/trex_server_info.py'")
                 try:
                     exec_cmd_no_error(
-                        tg_node, cmd, sudo=True,
+                        tg_node, command_line, sudo=True,
                         message=u"Test TRex failed!", retries=20
                     )
                 except RuntimeError:
@@ -488,16 +489,16 @@ class TrafficGenerator(AbstractMeasurer):
         :raises RuntimeError: If stop traffic script fails.
         """
         # No need to check subtype, we know it is TREX.
-        x_args = u""
+        command_line = OptionString().add(u"python3")
+        dirname = f"{Constants.REMOTE_FW_DIR}/GPL/tools/trex"
+        command_line.add(f"'{dirname}/trex_stateless_stop.py'")
+        command_line.change_prefix(u"--")
         for index, value in enumerate(self._xstats):
             if value is not None:
-                # Nested quoting is fun.
                 value = value.replace(u"'", u"\"")
-                x_args += f" --xstat{index}='\"'\"'{value}'\"'\"'"
+                command_line.add_equals(f"xstat{index}", f"'{value}'")
         stdout, _ = exec_cmd_no_error(
-            node, f"sh -c '{Constants.REMOTE_FW_DIR}/resources/tools/trex/"
-            f"trex_stateless_stop.py{x_args}'",
-            message=u"TRex stateless runtime error"
+            node, command_line, message=u"TRex stateless runtime error"
         )
         self._parse_traffic_results(stdout)
 
@@ -514,7 +515,7 @@ class TrafficGenerator(AbstractMeasurer):
         :param rate: Traffic rate expressed with units (pps, %)
         :param frame_size: L2 frame size to send (without padding and IPG).
         :param traffic_profile: Module name as a traffic profile identifier.
-            See resources/traffic_profiles/trex for implemented modules.
+            See GPL/traffic_profiles/trex for implemented modules.
         :param async_call: If enabled then don't wait for all incomming trafic.
         :param latency: With latency measurement.
         :param warmup_time: Warmup time period.
@@ -539,30 +540,31 @@ class TrafficGenerator(AbstractMeasurer):
         # No need to check subtype, we know it is TREX.
         reorder = self._ifaces_reordered  # Just to make the next line fit.
         p_0, p_1 = (rx_port, tx_port) if reorder else (tx_port, rx_port)
-
         if not isinstance(duration, (float, int)):
             duration = float(duration)
         if not isinstance(warmup_time, (float, int)):
             warmup_time = float(warmup_time)
-        command = f"sh -c \"" \
-            f"{Constants.REMOTE_FW_DIR}/resources/tools/trex/" \
-            f"trex_stateless_profile.py " \
-            f"--profile {Constants.REMOTE_FW_DIR}/resources/" \
-            f"traffic_profiles/trex/{traffic_profile}.py " \
-            f"--duration {duration!r} --frame_size {frame_size} " \
-            f"--rate {rate!r} --warmup_time {warmup_time!r} " \
-            f"--port_0 {p_0} --port_1 {p_1} " \
-            f"--traffic_directions {traffic_directions}"
-        if async_call:
-            command += u" --async_start"
-        if latency:
-            command += u" --latency"
-        if Constants.TREX_SEND_FORCE:
-            command += u" --force"
-        command += u"\""
+
+        command_line = OptionString().add(u"python3")
+        dirname = f"{Constants.REMOTE_FW_DIR}/GPL/tools/trex"
+        command_line.add(f"'{dirname}/trex_stateless_profile.py'")
+        command_line.change_prefix(u"--")
+        dirname = f"{Constants.REMOTE_FW_DIR}/GPL/traffic_profiles/trex"
+        quoted_path = f"'{dirname}/{traffic_profile}.py'"
+        command_line.add_with_value(u"profile", quoted_path)
+        command_line.add_with_value(u"duration", f"{duration!r}")
+        command_line.add_with_value(u"frame_size", frame_size)
+        command_line.add_with_value(u"rate", f"{rate!r}")
+        command_line.add_with_value(u"warmup_time", f"{warmup_time!r}")
+        command_line.add_with_value(u"port_0", p_0)
+        command_line.add_with_value(u"port_1", p_1)
+        command_line.add_with_value(u"traffic_directions", traffic_directions)
+        command_line.add_if(u"async_start", async_call)
+        command_line.add_if(u"latency", latency)
+        command_line.add_if(u"force", Constants.TREX_SEND_FORCE)
 
         stdout, _ = exec_cmd_no_error(
-            self._node, command, timeout=float(duration) + 60,
+            self._node, command_line, timeout=float(duration) + 60,
             message=u"TRex stateless runtime error"
         )
 
@@ -630,7 +632,7 @@ class TrafficGenerator(AbstractMeasurer):
         :param rate: Offered load per interface (e.g. 1%, 3gbps, 4mpps, ...).
         :param frame_size: Frame size (L2) in Bytes.
         :param traffic_profile: Module name as a traffic profile identifier.
-            See resources/traffic_profiles/trex for implemented modules.
+            See GPL/traffic_profiles/trex for implemented modules.
         :param warmup_time: Warmup phase in seconds.
         :param async_call: Async mode.
         :param latency: With latency measurement.
@@ -720,7 +722,7 @@ class TrafficGenerator(AbstractMeasurer):
 
         :param frame_size: Frame size identifier or value [B].
         :param traffic_profile: Module name as a traffic profile identifier.
-            See resources/traffic_profiles/trex for implemented modules.
+            See GPL/traffic_profiles/trex for implemented modules.
         :param warmup_time: Traffic duration before measurement starts [s].
         :param traffic_directions: Traffic is bi- (2) or uni- (1) directional.
             Default: 2
@@ -811,7 +813,7 @@ class OptimizedSearch:
 
         :param frame_size: Frame size identifier or value [B].
         :param traffic_profile: Module name as a traffic profile identifier.
-            See resources/traffic_profiles/trex for implemented modules.
+            See GPL/traffic_profiles/trex for implemented modules.
         :param minimum_transmit_rate: Minimal uni-directional
             target transmit rate [pps].
         :param maximum_transmit_rate: Maximal uni-directional
@@ -879,7 +881,7 @@ class OptimizedSearch:
 
         :param frame_size: Frame size identifier or value [B].
         :param traffic_profile: Module name as a traffic profile identifier.
-            See resources/traffic_profiles/trex for implemented modules.
+            See GPL/traffic_profiles/trex for implemented modules.
         :param minimum_transmit_rate: Minimal uni-directional
             target transmit rate [pps].
         :param maximum_transmit_rate: Maximal uni-directional
diff --git a/resources/libraries/python/TrafficScriptArg.py b/resources/libraries/python/TrafficScriptArg.py
deleted file mode 100644
index 247eccbc2f..0000000000
--- a/resources/libraries/python/TrafficScriptArg.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# Copyright (c) 2019 Cisco and/or its affiliates.
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at:
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Traffic scripts argument parser library."""
-
-import argparse
-
-
-class TrafficScriptArg:
-    """Traffic scripts argument parser.
-
-    Parse arguments for traffic script. Default has two arguments '--tx_if'
-    and '--rx_if'. You can provide more arguments. All arguments have string
-    representation of the value. You can add also optional arguments. Default
-    value for optional arguments is empty string.
-
-    :param more_args: List of additional arguments (optional).
-    :param opt_args: List of optional arguments (optional).
-    :type more_args: list
-    :type opt_args: list
-
-    :Example:
-
-    >>> from TrafficScriptArg import TrafficScriptArg
-    >>> args = TrafficScriptArg(['src_mac', 'dst_mac', 'src_ip', 'dst_ip'])
-    """
-
-    def __init__(self, more_args=None, opt_args=None):
-        parser = argparse.ArgumentParser()
-        parser.add_argument(u"--tx_if", help=u"interface that sends traffic")
-        parser.add_argument(u"--rx_if", help=u"interface that receives traffic")
-
-        if more_args is not None:
-            for arg in more_args:
-                arg_name = f"--{arg}"
-                parser.add_argument(arg_name)
-
-        if opt_args is not None:
-            for arg in opt_args:
-                arg_name = f"--{arg}"
-                parser.add_argument(arg_name, nargs=u"?", default=u"")
-
-        self._parser = parser
-        self._args = vars(parser.parse_args())
-
-    def get_arg(self, arg_name):
-        """Get argument value.
-
-        :param arg_name: Argument name.
-        :type arg_name: str
-        :returns: Argument value.
-        :rtype: str
-        """
-        arg_val = self._args.get(arg_name)
-        if arg_val is None:
-            raise Exception(f"Argument '{arg_name}' not found")
-
-        return arg_val
diff --git a/resources/libraries/python/TrafficScriptExecutor.py b/resources/libraries/python/TrafficScriptExecutor.py
index a9a733bbdf..8faa084ca1 100644
--- a/resources/libraries/python/TrafficScriptExecutor.py
+++ b/resources/libraries/python/TrafficScriptExecutor.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2019 Cisco and/or its affiliates.
+# Copyright (c) 2020 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -55,11 +55,11 @@ class TrafficScriptExecutor:
         """
         ssh = SSH()
         ssh.connect(node)
+        module_name = script_file_name[:-3].replace('/', '.')
         cmd = f"cd {Constants.REMOTE_FW_DIR}; virtualenv -p $(which python3) " \
             f"--system-site-packages --never-download env && " \
             f"export PYTHONPATH=${{PWD}}; . ${{PWD}}/env/bin/activate; " \
-            f"resources/traffic_scripts/{script_file_name} {script_args}"
-
+            f"cd GPL; python -m traffic_scripts.{module_name} {script_args}"
         ret_code, stdout, stderr = ssh.exec_command_sudo(
             f'sh -c "{TrafficScriptExecutor._escape(cmd)}"', timeout=timeout
         )