Neels Hofmeyr | 3531a19 | 2017-03-28 14:30:28 +0200 | [diff] [blame] | 1 | # osmo_gsm_tester: context for individual test runs |
Neels Hofmeyr | dae3d3c | 2017-03-28 12:16:58 +0200 | [diff] [blame] | 2 | # |
| 3 | # Copyright (C) 2016-2017 by sysmocom - s.f.m.c. GmbH |
| 4 | # |
| 5 | # Author: Neels Hofmeyr <neels@hofmeyr.de> |
| 6 | # |
| 7 | # This program is free software: you can redistribute it and/or modify |
Harald Welte | 2720534 | 2017-06-03 09:51:45 +0200 | [diff] [blame] | 8 | # it under the terms of the GNU General Public License as |
Neels Hofmeyr | dae3d3c | 2017-03-28 12:16:58 +0200 | [diff] [blame] | 9 | # published by the Free Software Foundation, either version 3 of the |
| 10 | # License, or (at your option) any later version. |
| 11 | # |
| 12 | # This program is distributed in the hope that it will be useful, |
| 13 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
Harald Welte | 2720534 | 2017-06-03 09:51:45 +0200 | [diff] [blame] | 15 | # GNU General Public License for more details. |
Neels Hofmeyr | dae3d3c | 2017-03-28 12:16:58 +0200 | [diff] [blame] | 16 | # |
Harald Welte | 2720534 | 2017-06-03 09:51:45 +0200 | [diff] [blame] | 17 | # You should have received a copy of the GNU General Public License |
Neels Hofmeyr | dae3d3c | 2017-03-28 12:16:58 +0200 | [diff] [blame] | 18 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 19 | |
Neels Hofmeyr | 3531a19 | 2017-03-28 14:30:28 +0200 | [diff] [blame] | 20 | # These will be initialized before each test run. |
| 21 | # A test script can thus establish its context by doing: |
Pau Espin Pedrol | dfe38ad | 2017-11-09 13:57:39 +0100 | [diff] [blame] | 22 | # from osmo_gsm_tester.testenv import * |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 23 | |
| 24 | import sys |
| 25 | |
Pau Espin Pedrol | 7cb6bad | 2020-09-18 15:17:08 +0200 | [diff] [blame] | 26 | from .core import util |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 27 | from .core import process |
Pau Espin Pedrol | 166dc10 | 2020-06-04 18:44:42 +0200 | [diff] [blame] | 28 | from .core import template |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 29 | from .core import log as log_module |
| 30 | from .core import process as process_module |
| 31 | from .core import resource |
| 32 | from .core.event_loop import MainLoop |
| 33 | |
Neels Hofmeyr | 3531a19 | 2017-03-28 14:30:28 +0200 | [diff] [blame] | 34 | suite = None |
Neels Hofmeyr | 3531a19 | 2017-03-28 14:30:28 +0200 | [diff] [blame] | 35 | log = None |
| 36 | dbg = None |
| 37 | err = None |
| 38 | wait = None |
Pau Espin Pedrol | 927344b | 2017-05-22 16:38:49 +0200 | [diff] [blame] | 39 | wait_no_raise = None |
Neels Hofmeyr | 3531a19 | 2017-03-28 14:30:28 +0200 | [diff] [blame] | 40 | sleep = None |
| 41 | poll = None |
| 42 | prompt = None |
Pau Espin Pedrol | 2d16f6f | 2017-05-30 15:33:57 +0200 | [diff] [blame] | 43 | Sms = None |
Pau Espin Pedrol | 878b2c6 | 2018-05-18 15:57:06 +0200 | [diff] [blame] | 44 | process = None |
Pau Espin Pedrol | 40c7bc7 | 2020-05-05 13:41:42 +0200 | [diff] [blame] | 45 | tenv = None |
Neels Hofmeyr | 3b493f3 | 2020-12-01 03:51:27 +0100 | [diff] [blame] | 46 | print = None |
Neels Hofmeyr | dae3d3c | 2017-03-28 12:16:58 +0200 | [diff] [blame] | 47 | |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 48 | class Timeout(Exception): |
| 49 | pass |
| 50 | |
| 51 | class TestEnv(log_module.Origin): |
| 52 | def __init__(self, suite_run, test): |
| 53 | super().__init__(log_module.C_TST, test.name()) |
| 54 | self.suite_run = suite_run |
| 55 | self._test = test |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 56 | self._processes = [] |
| 57 | self.test_import_modules_to_clean_up = [] |
| 58 | self.objects_to_clean_up = None |
| 59 | MainLoop.register_poll_func(self.poll) |
Pau Espin Pedrol | c3cf682 | 2020-06-12 17:54:55 +0200 | [diff] [blame] | 60 | if self._test.timeout is not None: # aimed at firing once |
Pau Espin Pedrol | 683d196 | 2020-06-15 11:39:41 +0200 | [diff] [blame] | 61 | MainLoop.register_poll_func(self._timeout_expired, timestep=self._test.timeout) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 62 | |
Pau Espin Pedrol | a442cb8 | 2020-05-05 12:54:37 +0200 | [diff] [blame] | 63 | def test(self): |
| 64 | return self._test |
| 65 | |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 66 | def suite(self): |
| 67 | return self.suite_run |
| 68 | |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 69 | def remember_to_stop(self, process, respawn=False): |
| 70 | '''Ask suite to monitor and manage lifecycle of the Process object. If a |
| 71 | process managed by suite finishes before cleanup time, the current test |
| 72 | will be marked as FAIL and end immediatelly. If respwan=True, then suite |
| 73 | will respawn() the process instead.''' |
| 74 | self._processes.insert(0, (process, respawn)) |
| 75 | |
| 76 | def stop_processes(self): |
| 77 | if len(self._processes) == 0: |
| 78 | return |
| 79 | strategy = process_module.ParallelTerminationStrategy() |
| 80 | while self._processes: |
| 81 | proc, _ = self._processes.pop() |
| 82 | strategy.add_process(proc) |
| 83 | strategy.terminate_all() |
| 84 | |
| 85 | def stop_process(self, process): |
| 86 | 'Remove process from monitored list and stop it' |
| 87 | for proc_respawn in self._processes: |
| 88 | proc, respawn = proc_respawn |
| 89 | if proc == process: |
| 90 | self._processes.remove(proc_respawn) |
| 91 | proc.terminate() |
| 92 | |
| 93 | def register_for_cleanup(self, *obj): |
| 94 | assert all([hasattr(o, 'cleanup') for o in obj]) |
| 95 | self.objects_to_clean_up = self.objects_to_clean_up or [] |
| 96 | self.objects_to_clean_up.extend(obj) |
| 97 | |
| 98 | def objects_cleanup(self): |
| 99 | while self.objects_to_clean_up: |
| 100 | obj = self.objects_to_clean_up.pop() |
| 101 | try: |
| 102 | obj.cleanup() |
| 103 | except Exception: |
| 104 | log_module.log_exn() |
| 105 | |
| 106 | def test_import_modules_register_for_cleanup(self, mod): |
| 107 | ''' |
| 108 | Tests are required to call this API for any module loaded from its own |
| 109 | lib subdir, because they are loaded in the global namespace. Otherwise |
| 110 | later tests importing modules with the same name will re-use an already |
| 111 | loaded module. |
| 112 | ''' |
| 113 | if mod not in self.test_import_modules_to_clean_up: |
| 114 | self.dbg('registering module %r for cleanup' % mod) |
| 115 | self.test_import_modules_to_clean_up.append(mod) |
| 116 | |
| 117 | def test_import_modules_cleanup(self): |
| 118 | while self.test_import_modules_to_clean_up: |
| 119 | mod = self.test_import_modules_to_clean_up.pop() |
| 120 | try: |
| 121 | self.dbg('Cleaning up module %r' % mod) |
| 122 | del sys.modules[mod.__name__] |
| 123 | del mod |
| 124 | except Exception: |
| 125 | log_module.log_exn() |
| 126 | |
Pau Espin Pedrol | 683d196 | 2020-06-15 11:39:41 +0200 | [diff] [blame] | 127 | def _timeout_expired(self): |
Pau Espin Pedrol | c3cf682 | 2020-06-12 17:54:55 +0200 | [diff] [blame] | 128 | # Avoid timeout being called several times: |
Pau Espin Pedrol | 683d196 | 2020-06-15 11:39:41 +0200 | [diff] [blame] | 129 | MainLoop.unregister_poll_func(self._timeout_expired) |
Pau Espin Pedrol | c3cf682 | 2020-06-12 17:54:55 +0200 | [diff] [blame] | 130 | raise log_module.Error('Test Timeout triggered: %d seconds elapsed' % self._test.elapsed_time()) |
| 131 | |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 132 | def poll(self): |
| 133 | for proc, respawn in self._processes: |
| 134 | if proc.terminated(): |
| 135 | if respawn == True: |
| 136 | proc.respawn() |
| 137 | else: |
| 138 | proc.log_stdout_tail() |
| 139 | proc.log_stderr_tail() |
| 140 | log_module.ctx(proc) |
| 141 | raise log_module.Error('Process ended prematurely: %s' % proc.name()) |
| 142 | |
| 143 | def stop(self): |
| 144 | # if sys.exit() called from signal handler (e.g. SIGINT), SystemExit |
| 145 | # base exception is raised. Make sure to stop processes in this |
| 146 | # finally section. Resources are automatically freed with 'atexit'. |
| 147 | self.stop_processes() |
| 148 | self.objects_cleanup() |
| 149 | self.suite_run.reserved_resources.put_all() |
| 150 | MainLoop.unregister_poll_func(self.poll) |
Pau Espin Pedrol | 683d196 | 2020-06-15 11:39:41 +0200 | [diff] [blame] | 151 | MainLoop.unregister_poll_func(self._timeout_expired) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 152 | self.test_import_modules_cleanup() |
Pau Espin Pedrol | 166dc10 | 2020-06-04 18:44:42 +0200 | [diff] [blame] | 153 | self.set_overlay_template_dir(None) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 154 | |
Pau Espin Pedrol | 3063730 | 2020-05-06 21:11:02 +0200 | [diff] [blame] | 155 | def config_suite_specific(self): |
| 156 | return self.suite_run.config_suite_specific() |
| 157 | |
| 158 | def config_test_specific(self): |
Pau Espin Pedrol | a75f85a | 2020-06-12 17:13:26 +0200 | [diff] [blame] | 159 | return self._test.config_test_specific() |
Pau Espin Pedrol | 3063730 | 2020-05-06 21:11:02 +0200 | [diff] [blame] | 160 | |
Pau Espin Pedrol | 166dc10 | 2020-06-04 18:44:42 +0200 | [diff] [blame] | 161 | def set_overlay_template_dir(self, template_dir=None): |
| 162 | '''Overlay a directory on top of default one when looking for |
| 163 | directories. It must be called everytime a template file is updated.''' |
| 164 | if template_dir is None: |
| 165 | template.set_templates_dir(template.default_templates_dir()) |
| 166 | else: |
Pau Espin Pedrol | a4bb6d3 | 2020-06-11 16:14:47 +0200 | [diff] [blame] | 167 | self.dbg('template dir overlay set: %s' % template_dir) |
Pau Espin Pedrol | 166dc10 | 2020-06-04 18:44:42 +0200 | [diff] [blame] | 168 | template.set_templates_dir(template_dir, template.default_templates_dir()) |
| 169 | |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 170 | def prompt(self, *msgs, **msg_details): |
| 171 | 'ask for user interaction. Do not use in tests that should run automatically!' |
| 172 | if msg_details: |
| 173 | msgs = list(msgs) |
| 174 | msgs.append('{%s}' % |
| 175 | (', '.join(['%s=%r' % (k,v) |
| 176 | for k,v in sorted(msg_details.items())]))) |
| 177 | msg = ' '.join(msgs) or 'Hit Enter to continue' |
| 178 | self.log('prompt:', msg) |
| 179 | sys.__stdout__.write('\n\n--- PROMPT ---\n') |
| 180 | sys.__stdout__.write(msg) |
| 181 | sys.__stdout__.write('\n') |
| 182 | sys.__stdout__.flush() |
| 183 | entered = util.input_polling('> ', MainLoop.poll) |
| 184 | self.log('prompt entered:', repr(entered)) |
| 185 | return entered |
| 186 | |
| 187 | def get_reserved_resource(self, resource_class_str, specifics=None): |
| 188 | return self.suite_run.get_reserved_resource(resource_class_str, specifics) |
| 189 | |
| 190 | def ip_address(self, specifics=None): |
| 191 | return self.get_reserved_resource(resource.R_IP_ADDRESS, specifics) |
| 192 | |
| 193 | def nitb(self, ip_address=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 194 | from .obj.nitb_osmo import OsmoNitb |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 195 | if ip_address is None: |
| 196 | ip_address = self.ip_address() |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 197 | return OsmoNitb(self, ip_address) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 198 | |
| 199 | def hlr(self, ip_address=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 200 | from .obj.hlr_osmo import OsmoHlr |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 201 | if ip_address is None: |
| 202 | ip_address = self.ip_address() |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 203 | return OsmoHlr(self, ip_address) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 204 | |
| 205 | def ggsn(self, ip_address=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 206 | from .obj.ggsn_osmo import OsmoGgsn |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 207 | if ip_address is None: |
| 208 | ip_address = self.ip_address() |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 209 | return OsmoGgsn(self, ip_address) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 210 | |
| 211 | def sgsn(self, hlr, ggsn, ip_address=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 212 | from .obj import sgsn_osmo |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 213 | if ip_address is None: |
| 214 | ip_address = self.ip_address() |
| 215 | return sgsn_osmo.OsmoSgsn(self, hlr, ggsn, ip_address) |
| 216 | |
| 217 | def mgcpgw(self, ip_address=None, bts_ip=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 218 | from .obj.mgcpgw_osmo import OsmoMgcpgw |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 219 | if ip_address is None: |
| 220 | ip_address = self.ip_address() |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 221 | return OsmoMgcpgw(self, ip_address, bts_ip) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 222 | |
| 223 | def mgw(self, ip_address=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 224 | from .obj.mgw_osmo import OsmoMgw |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 225 | if ip_address is None: |
| 226 | ip_address = self.ip_address() |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 227 | return OsmoMgw(self, ip_address) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 228 | |
| 229 | def msc(self, hlr, mgcpgw, stp, ip_address=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 230 | from .obj import msc_osmo |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 231 | if ip_address is None: |
| 232 | ip_address = self.ip_address() |
| 233 | return msc_osmo.OsmoMsc(self, hlr, mgcpgw, stp, ip_address) |
| 234 | |
| 235 | def bsc(self, msc, mgw, stp, ip_address=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 236 | from .obj.bsc_osmo import OsmoBsc |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 237 | if ip_address is None: |
| 238 | ip_address = self.ip_address() |
Neels Hofmeyr | af4e231 | 2020-11-27 08:20:56 +0100 | [diff] [blame] | 239 | bsc_obj = OsmoBsc(self, msc, mgw, stp, ip_address) |
| 240 | self.register_for_cleanup(bsc_obj) |
| 241 | return bsc_obj |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 242 | |
| 243 | def stp(self, ip_address=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 244 | from .obj.stp_osmo import OsmoStp |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 245 | if ip_address is None: |
| 246 | ip_address = self.ip_address() |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 247 | return OsmoStp(self, ip_address) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 248 | |
| 249 | def ms_driver(self): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 250 | from .obj.ms_driver import MsDriver |
| 251 | ms = MsDriver(self) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 252 | self.register_for_cleanup(ms) |
| 253 | return ms |
| 254 | |
| 255 | def bts(self, specifics=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 256 | from .obj.bts import Bts |
| 257 | bts_obj = Bts.get_instance_by_type(self, self.get_reserved_resource(resource.R_BTS, specifics=specifics)) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 258 | bts_obj.set_lac(self.lac()) |
| 259 | bts_obj.set_rac(self.rac()) |
| 260 | bts_obj.set_cellid(self.cellid()) |
| 261 | bts_obj.set_bvci(self.bvci()) |
| 262 | self.register_for_cleanup(bts_obj) |
| 263 | return bts_obj |
| 264 | |
| 265 | def modem(self, specifics=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 266 | from .obj.ms import MS |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 267 | conf = self.get_reserved_resource(resource.R_MODEM, specifics=specifics) |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 268 | ms_obj = MS.get_instance_by_type(self, conf) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 269 | self.register_for_cleanup(ms_obj) |
| 270 | return ms_obj |
| 271 | |
| 272 | def modems(self, count): |
| 273 | l = [] |
| 274 | for i in range(count): |
| 275 | l.append(self.modem()) |
| 276 | return l |
| 277 | |
| 278 | def all_resources(self, resource_func): |
| 279 | """Returns all yielded resource.""" |
| 280 | l = [] |
| 281 | while True: |
| 282 | try: |
| 283 | l.append(resource_func()) |
| 284 | except resource.NoResourceExn: |
| 285 | return l |
| 286 | |
| 287 | def esme(self): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 288 | from .obj.esme import Esme |
| 289 | esme_obj = Esme(self.msisdn()) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 290 | self.register_for_cleanup(esme_obj) |
| 291 | return esme_obj |
| 292 | |
| 293 | def run_node(self, specifics=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 294 | from .obj.run_node import RunNode |
| 295 | return RunNode.from_conf(self.get_reserved_resource(resource.R_RUN_NODE, specifics=specifics)) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 296 | |
| 297 | def enb(self, specifics=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 298 | from .obj.enb import eNodeB |
| 299 | enb_obj = eNodeB.get_instance_by_type(self, self.get_reserved_resource(resource.R_ENB, specifics=specifics)) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 300 | self.register_for_cleanup(enb_obj) |
| 301 | return enb_obj |
| 302 | |
| 303 | def epc(self, run_node=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 304 | from .obj.epc import EPC |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 305 | if run_node is None: |
| 306 | run_node = self.run_node() |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 307 | epc_obj = EPC.get_instance_by_type(self, run_node) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 308 | self.register_for_cleanup(epc_obj) |
| 309 | return epc_obj |
| 310 | |
| 311 | def osmocon(self, specifics=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 312 | from .obj.osmocon import Osmocon |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 313 | conf = self.get_reserved_resource(resource.R_OSMOCON, specifics=specifics) |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 314 | osmocon_obj = Osmocon(self, conf=conf) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 315 | self.register_for_cleanup(osmocon_obj) |
| 316 | return osmocon_obj |
| 317 | |
| 318 | def iperf3srv(self, ip_address=None): |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 319 | from .obj.iperf3 import IPerf3Server |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 320 | if ip_address is None: |
| 321 | ip_address = self.ip_address() |
Pau Espin Pedrol | 5b9c7b9 | 2020-05-05 14:35:04 +0200 | [diff] [blame] | 322 | iperf3srv_obj = IPerf3Server(self, ip_address) |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 323 | return iperf3srv_obj |
| 324 | |
Pau Espin Pedrol | 969a4ee | 2020-07-02 13:21:08 +0200 | [diff] [blame] | 325 | def stress(self, run_node=None): |
| 326 | from .obj.stress import StressTool |
| 327 | stress_obj = StressTool(self, run_node) |
| 328 | return stress_obj |
| 329 | |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 330 | def msisdn(self): |
| 331 | msisdn = self.suite_run.resource_pool().next_msisdn(self) |
| 332 | self.log('using MSISDN', msisdn) |
| 333 | return msisdn |
| 334 | |
| 335 | def lac(self): |
| 336 | lac = self.suite_run.resource_pool().next_lac(self) |
| 337 | self.log('using LAC', lac) |
| 338 | return lac |
| 339 | |
| 340 | def rac(self): |
| 341 | rac = self.suite_run.resource_pool().next_rac(self) |
| 342 | self.log('using RAC', rac) |
| 343 | return rac |
| 344 | |
| 345 | def cellid(self): |
| 346 | cellid = self.suite_run.resource_pool().next_cellid(self) |
| 347 | self.log('using CellId', cellid) |
| 348 | return cellid |
| 349 | |
| 350 | def bvci(self): |
| 351 | bvci = self.suite_run.resource_pool().next_bvci(self) |
| 352 | self.log('using BVCI', bvci) |
| 353 | return bvci |
| 354 | |
Neels Hofmeyr | 3b493f3 | 2020-12-01 03:51:27 +0100 | [diff] [blame] | 355 | def print(self, *messages, **named_items): |
| 356 | log_module.log(*messages, _origin=self.test(), _src=3, **named_items) |
| 357 | |
Pau Espin Pedrol | aa1cbdc | 2020-05-04 20:21:31 +0200 | [diff] [blame] | 358 | |
Pau Espin Pedrol | ee217b0 | 2020-05-04 19:06:47 +0200 | [diff] [blame] | 359 | def setup(suite_run, _test): |
Pau Espin Pedrol | ee217b0 | 2020-05-04 19:06:47 +0200 | [diff] [blame] | 360 | from .core.event_loop import MainLoop |
| 361 | from .obj.sms import Sms as Sms_class |
Pau Espin Pedrol | ee217b0 | 2020-05-04 19:06:47 +0200 | [diff] [blame] | 362 | |
Neels Hofmeyr | 3b493f3 | 2020-12-01 03:51:27 +0100 | [diff] [blame] | 363 | global test, log, dbg, err, wait, wait_no_raise, sleep, poll, prompt, Sms, process, tenv, print |
Pau Espin Pedrol | ee217b0 | 2020-05-04 19:06:47 +0200 | [diff] [blame] | 364 | |
Neels Hofmeyr | 3531a19 | 2017-03-28 14:30:28 +0200 | [diff] [blame] | 365 | test = _test |
Neels Hofmeyr | 3531a19 | 2017-03-28 14:30:28 +0200 | [diff] [blame] | 366 | log = test.log |
| 367 | dbg = test.dbg |
| 368 | err = test.err |
Pau Espin Pedrol | 664e383 | 2020-06-10 19:30:33 +0200 | [diff] [blame] | 369 | tenv = TestEnv(suite_run, _test) |
| 370 | wait = MainLoop.wait |
| 371 | wait_no_raise = MainLoop.wait_no_raise |
| 372 | sleep = MainLoop.sleep |
Pau Espin Pedrol | ee217b0 | 2020-05-04 19:06:47 +0200 | [diff] [blame] | 373 | poll = MainLoop.poll |
Pau Espin Pedrol | ee217b0 | 2020-05-04 19:06:47 +0200 | [diff] [blame] | 374 | Sms = Sms_class |
Pau Espin Pedrol | 878b2c6 | 2018-05-18 15:57:06 +0200 | [diff] [blame] | 375 | process = process_module |
Pau Espin Pedrol | 40c7bc7 | 2020-05-05 13:41:42 +0200 | [diff] [blame] | 376 | prompt = tenv.prompt |
Neels Hofmeyr | 3b493f3 | 2020-12-01 03:51:27 +0100 | [diff] [blame] | 377 | print = tenv.print |
Pau Espin Pedrol | 40c7bc7 | 2020-05-05 13:41:42 +0200 | [diff] [blame] | 378 | return tenv |
Neels Hofmeyr | dae3d3c | 2017-03-28 12:16:58 +0200 | [diff] [blame] | 379 | |
Neels Hofmeyr | dae3d3c | 2017-03-28 12:16:58 +0200 | [diff] [blame] | 380 | # vim: expandtab tabstop=4 shiftwidth=4 |