import sys
import tty, termios
-from trex_control_plane.stl.api import *
+from trex_stl_lib.api import *
-from trex_control_plane.common.text_opts import *
-from trex_control_plane.client_utils.general_utils import user_input, get_current_user
-from trex_control_plane.client_utils import parsing_opts
+from trex_stl_lib.utils.text_opts import *
+from trex_stl_lib.utils.common import user_input, get_current_user
+from trex_stl_lib.utils import parsing_opts
import trex_tui
import datetime
from cStringIO import StringIO
-from common.text_opts import *
-from client_utils import text_tables
+from trex_stl_lib.utils.text_opts import *
+from trex_stl_lib.utils import text_tables
# for STL exceptions
-from trex_control_plane.stl.api import *
+from trex_stl_lib.api import *
class SimpleBar(object):
def __init__ (self, desc, pattern):
# get external libs
-import trex_control_plane.client_utils.external_packages
+import trex_stl_ext
# client and exceptions
from trex_stl_exceptions import *
from trex_stl_jsonrpc_client import JsonRpcClient, BatchMessage
-from common.text_opts import *
+from utils.text_opts import *
from trex_stl_stats import *
from trex_stl_types import *
#!/router/bin/python
# for API usage the path name must be full
-from trex_control_plane.stl.trex_stl_exceptions import *
-#from trex_control_plane.stl.trex_stl_streams import *
-from trex_stl_streams import *
+from trex_stl_lib.trex_stl_exceptions import *
+from trex_stl_lib.trex_stl_streams import *
from trex_stl_jsonrpc_client import JsonRpcClient, BatchMessage
import trex_stl_stats
from trex_stl_types import *
from trex_stl_async_client import CTRexAsyncClient
-from trex_control_plane.client_utils import parsing_opts, text_tables, general_utils
-from trex_control_plane.common.text_opts import *
+from utils import parsing_opts, text_tables, common
+from utils.text_opts import *
from collections import namedtuple
import re
import random
import json
+import traceback
############################ logger #############################
############################ #############################
"""docstring for STLClient"""
def __init__(self,
- username = general_utils.get_current_user(),
+ username = common.get_current_user(),
server = "localhost",
sync_port = 4501,
async_port = 4500,
import os
import sys
-from trex_control_plane.common.text_opts import *
+from utils.text_opts import *
# basic error for API
class STLError(Exception):
--- /dev/null
+import sys
+import os
+import warnings
+
+# if not set - set it to default
+if not 'TREX_STL_EXT_PATH' in globals():
+ CURRENT_PATH = os.path.dirname(os.path.realpath(__file__))
+ # ../../../../external_libs
+ TREX_STL_EXT_PATH = os.path.abspath(os.path.join(CURRENT_PATH, os.pardir, os.pardir, os.pardir, os.pardir, 'external_libs'))
+
+# check path exists
+if not os.path.exists(TREX_STL_EXT_PATH):
+ print "Unable to find external packages path: '{0}'".format(TREX_STL_EXT_PATH)
+ print "Please provide the correct path using TREX_STL_EXT_PATH variable"
+ exit(0)
+
+# the modules required
+CLIENT_UTILS_MODULES = ['dpkt-1.8.6',
+ 'yaml-3.11',
+ 'texttable-0.8.4',
+ 'scapy-2.3.1'
+ ]
+
+def import_client_utils_modules():
+ import_module_list(CLIENT_UTILS_MODULES)
+
+
+def import_module_list(modules_list):
+ assert(isinstance(modules_list, list))
+ for p in modules_list:
+ full_path = os.path.join(TREX_STL_EXT_PATH, p)
+ fix_path = os.path.normcase(full_path)
+ sys.path.insert(1, full_path)
+
+
+ import_platform_dirs()
+
+
+
+def import_platform_dirs ():
+ # handle platform dirs
+
+ # try fedora 18 first and then cel5.9
+ # we are using the ZMQ module to determine the right platform
+
+ full_path = os.path.join(TREX_STL_EXT_PATH, 'platform/fedora18')
+ fix_path = os.path.normcase(full_path)
+ sys.path.insert(0, full_path)
+ try:
+ # try to import and delete it from the namespace
+ import zmq
+ del zmq
+ return
+ except:
+ sys.path.pop(0)
+ pass
+
+ full_path = os.path.join(TREX_STL_EXT_PATH, 'platform/cel59')
+ fix_path = os.path.normcase(full_path)
+ sys.path.insert(0, full_path)
+ try:
+ # try to import and delete it from the namespace
+ import zmq
+ del zmq
+ return
+
+ except:
+ sys.path.pop(0)
+ sys.modules['zmq'] = None
+ warnings.warn("unable to determine platform type for ZMQ import")
+
+
+import_client_utils_modules()
+
import zmq
import json
-import client_utils.general_utils
import re
from time import sleep
from collections import namedtuple
from trex_stl_types import *
+from utils.common import random_id_gen
class bcolors:
BLUE = '\033[94m'
# default values
self.port = default_port
self.server = default_server
- self.id_gen = client_utils.general_utils.random_id_gen()
+
+ self.id_gen = random_id_gen()
def get_connection_details (self):
################################################################################################
-lass CScapyTRexPktBuilder(CTrexPktBuilderInterface):
+class CScapyTRexPktBuilder(CTrexPktBuilderInterface):
"""
This class defines the TRex API of building a packet using dpkt package.
return p_utl.get_field_offet_by_str(field_name)
def _get_pkt_as_str(self):
- if self.pkt :
- str(self.pkt)
+ if self.pkt:
+ return str(self.pkt)
if self.pkt_raw:
return self.pkt_raw
- raise CTRexPacketBuildException(-11,('empty packet') % (var_name) );
+ raise CTRexPacketBuildException(-11, 'empty packet');
def _add_tuple_gen(self,tuple_gen):
See the License for the specific language governing permissions and
limitations under the License.
"""
+# simulator can be run as a standalone
+import trex_stl_ext
+
from trex_stl_exceptions import *
from yaml import YAMLError
from trex_stl_streams import *
-from client_utils import parsing_opts
+from utils import parsing_opts
from trex_stl_client import STLClient
import re
# load streams
cmds_json = []
+
+ id = 1
+
+ lookup = {}
+ # allocate IDs
+ for stream in stream_list:
+ if stream.get_id() == None:
+ stream.set_id(id)
+ id += 1
+
+ lookup[stream.get_name()] = stream.get_id()
+
+ # resolve names
+ for stream in stream_list:
+ next_id = -1
+ next = stream.get_next()
+ if next:
+ if not next in lookup:
+ raise STLError("stream dependency error - unable to find '{0}'".format(next))
+ next_id = lookup[next]
+
+ stream.fields['next_stream_id'] = next_id
+
for stream in stream_list:
cmd = {"id":1,
"jsonrpc": "2.0",
#!/router/bin/python
-from client_utils import text_tables
-from common.text_opts import format_text, format_threshold, format_num
+from utils import text_tables
+from utils.text_opts import format_text, format_threshold, format_num
from trex_stl_async_client import CTRexAsyncStats
from trex_stl_packet_builder_scapy import CScapyTRexPktBuilder, Ether, IP
from collections import OrderedDict, namedtuple
-from trex_control_plane.client_utils.yaml_utils import *
-
from dpkt import pcap
import random
import yaml
# packet builder
packet.compile()
+
# packet and VM
self.fields['packet'] = packet.dump_pkt()
self.fields['vm'] = packet.get_vm_data()
from collections import namedtuple
-from common.text_opts import *
+from utils.text_opts import *
RpcCmdData = namedtuple('RpcCmdData', ['method', 'params'])
--- /dev/null
+import os
+import sys
+import string
+import random
+
+try:
+ import pwd
+except ImportError:
+ import getpass
+ pwd = None
+
+using_python_3 = True if sys.version_info.major == 3 else False
+
+def get_current_user():
+ if pwd:
+ return pwd.getpwuid(os.geteuid()).pw_name
+ else:
+ return getpass.getuser()
+
+
+def user_input():
+ if using_python_3:
+ return input()
+ else:
+ # using python version 2
+ return raw_input()
+
+
+def random_id_gen(length=8):
+ """
+ A generator for creating a random chars id of specific length
+
+ :parameters:
+ length : int
+ the desired length of the generated id
+
+ default: 8
+
+ :return:
+ a random id with each next() request.
+ """
+ id_chars = string.ascii_lowercase + string.digits
+ while True:
+ return_id = ''
+ for i in range(length):
+ return_id += random.choice(id_chars)
+ yield return_id
--- /dev/null
+import json
+import re
+
+TEXT_CODES = {'bold': {'start': '\x1b[1m',
+ 'end': '\x1b[22m'},
+ 'cyan': {'start': '\x1b[36m',
+ 'end': '\x1b[39m'},
+ 'blue': {'start': '\x1b[34m',
+ 'end': '\x1b[39m'},
+ 'red': {'start': '\x1b[31m',
+ 'end': '\x1b[39m'},
+ 'magenta': {'start': '\x1b[35m',
+ 'end': '\x1b[39m'},
+ 'green': {'start': '\x1b[32m',
+ 'end': '\x1b[39m'},
+ 'yellow': {'start': '\x1b[33m',
+ 'end': '\x1b[39m'},
+ 'underline': {'start': '\x1b[4m',
+ 'end': '\x1b[24m'}}
+
+class TextCodesStripper:
+ keys = [re.escape(v['start']) for k,v in TEXT_CODES.iteritems()]
+ keys += [re.escape(v['end']) for k,v in TEXT_CODES.iteritems()]
+ pattern = re.compile("|".join(keys))
+
+ @staticmethod
+ def strip (s):
+ return re.sub(TextCodesStripper.pattern, '', s)
+
+def format_num (size, suffix = "", compact = True, opts = ()):
+ txt = "NaN"
+
+ if type(size) == str:
+ return "N/A"
+
+ u = ''
+
+ if compact:
+ for unit in ['','K','M','G','T','P']:
+ if abs(size) < 1000.0:
+ u = unit
+ break
+ size /= 1000.0
+
+ if isinstance(size, float):
+ txt = "%3.2f" % (size)
+ else:
+ txt = "{:,}".format(size)
+
+ if u or suffix:
+ txt += " {:}{:}".format(u, suffix)
+
+ if isinstance(opts, tuple):
+ return format_text(txt, *opts)
+ else:
+ return format_text(txt, (opts))
+
+
+
+def format_time (t_sec):
+ if t_sec < 0:
+ return "infinite"
+
+ if t_sec < 1:
+ # low numbers
+ for unit in ['ms', 'usec', 'ns']:
+ t_sec *= 1000.0
+ if t_sec >= 1.0:
+ return '{:,.2f} [{:}]'.format(t_sec, unit)
+
+ return "NaN"
+
+ else:
+ # seconds
+ if t_sec < 60.0:
+ return '{:,.2f} [{:}]'.format(t_sec, 'sec')
+
+ # minutes
+ t_sec /= 60.0
+ if t_sec < 60.0:
+ return '{:,.2f} [{:}]'.format(t_sec, 'minutes')
+
+ # hours
+ t_sec /= 60.0
+ if t_sec < 24.0:
+ return '{:,.2f} [{:}]'.format(t_sec, 'hours')
+
+ # days
+ t_sec /= 24.0
+ return '{:,.2f} [{:}]'.format(t_sec, 'days')
+
+
+def format_percentage (size):
+ return "%0.2f %%" % (size)
+
+def bold(text):
+ return text_attribute(text, 'bold')
+
+
+def cyan(text):
+ return text_attribute(text, 'cyan')
+
+
+def blue(text):
+ return text_attribute(text, 'blue')
+
+
+def red(text):
+ return text_attribute(text, 'red')
+
+
+def magenta(text):
+ return text_attribute(text, 'magenta')
+
+
+def green(text):
+ return text_attribute(text, 'green')
+
+def yellow(text):
+ return text_attribute(text, 'yellow')
+
+def underline(text):
+ return text_attribute(text, 'underline')
+
+
+def text_attribute(text, attribute):
+ if isinstance(text, str):
+ return "{start}{txt}{stop}".format(start=TEXT_CODES[attribute]['start'],
+ txt=text,
+ stop=TEXT_CODES[attribute]['end'])
+ elif isinstance(text, unicode):
+ return u"{start}{txt}{stop}".format(start=TEXT_CODES[attribute]['start'],
+ txt=text,
+ stop=TEXT_CODES[attribute]['end'])
+ else:
+ raise Exception("not a string")
+
+
+FUNC_DICT = {'blue': blue,
+ 'bold': bold,
+ 'green': green,
+ 'yellow': yellow,
+ 'cyan': cyan,
+ 'magenta': magenta,
+ 'underline': underline,
+ 'red': red}
+
+
+def format_text(text, *args):
+ return_string = text
+ for i in args:
+ func = FUNC_DICT.get(i)
+ if func:
+ return_string = func(return_string)
+
+ return return_string
+
+
+def format_threshold (value, red_zone, green_zone):
+ if value >= red_zone[0] and value <= red_zone[1]:
+ return format_text("{0}".format(value), 'red')
+
+ if value >= green_zone[0] and value <= green_zone[1]:
+ return format_text("{0}".format(value), 'green')
+
+ return "{0}".format(value)
+
+# pretty print for JSON
+def pretty_json (json_str, use_colors = True):
+ pretty_str = json.dumps(json.loads(json_str), indent = 4, separators=(',', ': '), sort_keys = True)
+
+ if not use_colors:
+ return pretty_str
+
+ try:
+ # int numbers
+ pretty_str = re.sub(r'([ ]*:[ ]+)(\-?[1-9][0-9]*[^.])',r'\1{0}'.format(blue(r'\2')), pretty_str)
+ # float
+ pretty_str = re.sub(r'([ ]*:[ ]+)(\-?[1-9][0-9]*\.[0-9]+)',r'\1{0}'.format(magenta(r'\2')), pretty_str)
+ # # strings
+ #
+ pretty_str = re.sub(r'([ ]*:[ ]+)("[^"]*")',r'\1{0}'.format(red(r'\2')), pretty_str)
+ pretty_str = re.sub(r"('[^']*')", r'{0}\1{1}'.format(TEXT_CODES['magenta']['start'],
+ TEXT_CODES['red']['start']), pretty_str)
+ except :
+ pass
+
+ return pretty_str
+
+
+if __name__ == "__main__":
+ pass
from texttable import Texttable
-from trex_control_plane.common.text_opts import format_text
+from text_opts import format_text
class TRexTextTable(Texttable):
+++ /dev/null
-import trex_control_plane.console.trex_console
-
-trex_control_plane.console.trex_console.main()
+++ /dev/null
-import trex_control_plane.stl.api
-import trex_control_plane.stl.trex_stl_sim
-
-trex_control_plane.stl.trex_stl_sim.main()
import sys
import string
-from common import text_opts
+import re
try:
if sys.version >= '2.3':
return iterable.__len__()
+TEXT_CODES = {'bold': {'start': '\x1b[1m',
+ 'end': '\x1b[22m'},
+ 'cyan': {'start': '\x1b[36m',
+ 'end': '\x1b[39m'},
+ 'blue': {'start': '\x1b[34m',
+ 'end': '\x1b[39m'},
+ 'red': {'start': '\x1b[31m',
+ 'end': '\x1b[39m'},
+ 'magenta': {'start': '\x1b[35m',
+ 'end': '\x1b[39m'},
+ 'green': {'start': '\x1b[32m',
+ 'end': '\x1b[39m'},
+ 'yellow': {'start': '\x1b[33m',
+ 'end': '\x1b[39m'},
+ 'underline': {'start': '\x1b[4m',
+ 'end': '\x1b[24m'}}
+
+class TextCodesStripper:
+ keys = [re.escape(v['start']) for k,v in TEXT_CODES.iteritems()]
+ keys += [re.escape(v['end']) for k,v in TEXT_CODES.iteritems()]
+ pattern = re.compile("|".join(keys))
+
+ @staticmethod
+ def strip (s):
+ return re.sub(TextCodesStripper.pattern, '', s)
+
def ansi_len (iterable):
- return len(text_opts.TextCodesStripper.strip(iterable))
+ return len(TextCodesStripper.strip(iterable))
class ArraySizeError(Exception):
#!/bin/bash
source find_python.sh
-$PYTHON automation/wrap_stl_sim.py $@
+export PYTHONPATH=automation/trex_control_plane/stl
+$PYTHON -m trex_stl_lib.trex_stl_sim $@
-from trex_control_plane.stl.api import *
+from trex_stl_lib.api import *
# IMIX profile - involves 3 streams of UDP packets
# 1 - 60 bytes
#!/bin/bash
source find_python.sh
-$PYTHON automation/wrap_stl_console.py $@
+export PYTHONPATH=automation/trex_control_plane/stl
+$PYTHON -m console.trex_console $@
Code Review / trex.git / commitdiff