7 from framework import VppTestCase
8 from multiprocessing import Process, Pipe
9 from pickle import dumps
12 from enum import IntEnum, IntFlag
15 class SerializableClassCopy:
17 Empty class used as a basis for a serializable copy of another class.
22 return '<SerializableClassCopy dict=%s>' % self.__dict__
25 class RemoteClassAttr:
27 Wrapper around attribute of a remotely executed class.
30 def __init__(self, remote, attr):
31 self._path = [attr] if attr else []
34 def path_to_str(self):
35 return '.'.join(self._path)
37 def get_remote_value(self):
38 return self._remote._remote_exec(RemoteClass.GET, self.path_to_str())
41 return self._remote._remote_exec(RemoteClass.REPR, self.path_to_str())
44 return self._remote._remote_exec(RemoteClass.STR, self.path_to_str())
46 def __getattr__(self, attr):
48 if not (attr.startswith('__') and attr.endswith('__')):
49 raise AttributeError('tried to get private attribute: %s ',
51 self._path.append(attr)
54 def __setattr__(self, attr, val):
56 if not (attr.startswith('__') and attr.endswith('__')):
57 super(RemoteClassAttr, self).__setattr__(attr, val)
59 self._path.append(attr)
60 self._remote._remote_exec(RemoteClass.SETATTR, self.path_to_str(),
63 def __call__(self, *args, **kwargs):
64 return self._remote._remote_exec(RemoteClass.CALL, self.path_to_str(),
68 class RemoteClass(Process):
70 This class can wrap around and adapt the interface of another class,
71 and then delegate its execution to a newly forked child process.
75 #. Create a remotely executed instance of MyClass. ::
77 object = RemoteClass(MyClass, arg1='foo', arg2='bar')
80 #. Access the object normally as if it was an instance of your
83 object.my_attribute = 20
84 print object.my_attribute
85 print object.my_method(object.my_attribute)
86 object.my_attribute.nested_attribute = 'test'
88 #. If you need the value of a remote attribute, use .get_remote_value
89 method. This method is automatically called when needed in the
90 context of a remotely executed class. E.g. ::
92 if (object.my_attribute.get_remote_value() > 20):
93 object.my_attribute2 = object.my_attribute
95 #. Destroy the instance. ::
101 GET = 0 # Get attribute remotely
102 CALL = 1 # Call method remotely
103 SETATTR = 2 # Set attribute remotely
104 REPR = 3 # Get representation of a remote object
105 STR = 4 # Get string representation of a remote object
106 QUIT = 5 # Quit remote execution
108 PIPE_PARENT = 0 # Parent end of the pipe
109 PIPE_CHILD = 1 # Child end of the pipe
111 DEFAULT_TIMEOUT = 2 # default timeout for an operation to execute
113 def __init__(self, cls, *args, **kwargs):
114 super(RemoteClass, self).__init__()
117 self._kwargs = kwargs
118 self._timeout = RemoteClass.DEFAULT_TIMEOUT
119 self._pipe = Pipe() # pipe for input/output arguments
122 return reprlib.repr(RemoteClassAttr(self, None))
125 return str(RemoteClassAttr(self, None))
127 def __call__(self, *args, **kwargs):
128 return self.RemoteClassAttr(self, None)()
130 def __getattr__(self, attr):
131 if attr[0] == '_' or not self.is_alive():
132 if not (attr.startswith('__') and attr.endswith('__')):
133 if hasattr(super(RemoteClass, self), '__getattr__'):
134 return super(RemoteClass, self).__getattr__(attr)
135 raise AttributeError('missing: %s', attr)
136 return RemoteClassAttr(self, attr)
138 def __setattr__(self, attr, val):
139 if attr[0] == '_' or not self.is_alive():
140 if not (attr.startswith('__') and attr.endswith('__')):
141 super(RemoteClass, self).__setattr__(attr, val)
143 setattr(RemoteClassAttr(self, None), attr, val)
145 def _remote_exec(self, op, path=None, *args, **kwargs):
147 Execute given operation on a given, possibly nested, member remotely.
149 # automatically resolve remote objects in the arguments
150 mutable_args = list(args)
151 for i, val in enumerate(mutable_args):
152 if isinstance(val, RemoteClass) or \
153 isinstance(val, RemoteClassAttr):
154 mutable_args[i] = val.get_remote_value()
155 args = tuple(mutable_args)
156 for key, val in kwargs.items():
157 if isinstance(val, RemoteClass) or \
158 isinstance(val, RemoteClassAttr):
159 kwargs[key] = val.get_remote_value()
161 args = self._make_serializable(args)
162 kwargs = self._make_serializable(kwargs)
163 self._pipe[RemoteClass.PIPE_PARENT].send((op, path, args, kwargs))
164 timeout = self._timeout
165 # adjust timeout specifically for the .sleep method
166 if path is not None and path.split('.')[-1] == 'sleep':
167 if args and isinstance(args[0], (long, int)):
169 elif 'timeout' in kwargs:
170 timeout += kwargs['timeout']
171 if not self._pipe[RemoteClass.PIPE_PARENT].poll(timeout):
174 rv = self._pipe[RemoteClass.PIPE_PARENT].recv()
175 rv = self._deserialize(rv)
180 def _get_local_object(self, path):
182 Follow the path to obtain a reference on the addressed nested attribute
186 obj = getattr(obj, attr)
189 def _get_local_value(self, path):
191 return self._get_local_object(path)
192 except AttributeError:
195 def _call_local_method(self, path, *args, **kwargs):
197 method = self._get_local_object(path)
198 return method(*args, **kwargs)
199 except AttributeError:
202 def _set_local_attr(self, path, value):
204 obj = self._get_local_object(path[:-1])
205 setattr(obj, path[-1], value)
206 except AttributeError:
210 def _get_local_repr(self, path):
212 obj = self._get_local_object(path)
213 return reprlib.repr(obj)
214 except AttributeError:
217 def _get_local_str(self, path):
219 obj = self._get_local_object(path)
221 except AttributeError:
224 def _serializable(self, obj):
225 """ Test if the given object is serializable """
232 def _make_obj_serializable(self, obj):
234 Make a serializable copy of an object.
235 Members which are difficult/impossible to serialize are stripped.
237 if self._serializable(obj):
238 return obj # already serializable
240 copy = SerializableClassCopy()
243 Dictionaries can hold complex values, so we split keys and values into
244 separate lists and serialize them individually.
246 if (type(obj) is dict):
247 copy.type = type(obj)
250 for k, v in obj.items():
251 copy.k_list.append(self._make_serializable(k))
252 copy.v_list.append(self._make_serializable(v))
255 # copy at least serializable attributes and properties
256 for name, member in inspect.getmembers(obj):
257 # skip private members and non-writable dunder methods.
259 if name in ['__weakref__']:
261 if name in ['__dict__']:
263 if not (name.startswith('__') and name.endswith('__')):
265 if callable(member) and not isinstance(member, property):
267 if not self._serializable(member):
268 member = self._make_serializable(member)
269 setattr(copy, name, member)
272 def _make_serializable(self, obj):
274 Make a serializable copy of an object or a list/tuple of objects.
275 Members which are difficult/impossible to serialize are stripped.
277 if (type(obj) is list) or (type(obj) is tuple):
280 rv.append(self._make_serializable(item))
281 if type(obj) is tuple:
284 elif (isinstance(obj, IntEnum) or isinstance(obj, IntFlag)):
287 return self._make_obj_serializable(obj)
289 def _deserialize_obj(self, obj):
290 if (hasattr(obj, 'type')):
293 for k, v in zip(obj.k_list, obj.v_list):
294 _obj[self._deserialize(k)] = self._deserialize(v)
298 def _deserialize(self, obj):
299 if (type(obj) is list) or (type(obj) is tuple):
302 rv.append(self._deserialize(item))
303 if type(obj) is tuple:
307 return self._deserialize_obj(obj)
309 def start_remote(self):
310 """ Start remote execution """
313 def quit_remote(self):
314 """ Quit remote execution """
315 self._remote_exec(RemoteClass.QUIT, None)
317 def get_remote_value(self):
318 """ Get value of a remotely held object """
319 return RemoteClassAttr(self, None).get_remote_value()
321 def set_request_timeout(self, timeout):
322 """ Change request timeout """
323 self._timeout = timeout
327 Create instance of the wrapped class and execute operations
328 on it as requested by the parent process.
330 self._instance = self._cls(*self._args, **self._kwargs)
334 # get request from the parent process
336 kwargs) = self._pipe[RemoteClass.PIPE_CHILD].recv()
337 args = self._deserialize(args)
338 kwargs = self._deserialize(kwargs)
339 path = path.split('.') if path else []
340 if op == RemoteClass.GET:
341 rv = self._get_local_value(path)
342 elif op == RemoteClass.CALL:
343 rv = self._call_local_method(path, *args, **kwargs)
344 elif op == RemoteClass.SETATTR and 'value' in kwargs:
345 self._set_local_attr(path, kwargs['value'])
346 elif op == RemoteClass.REPR:
347 rv = self._get_local_repr(path)
348 elif op == RemoteClass.STR:
349 rv = self._get_local_str(path)
350 elif op == RemoteClass.QUIT:
355 if not self._serializable(rv):
356 rv = self._make_serializable(rv)
357 self._pipe[RemoteClass.PIPE_CHILD].send(rv)
360 self._instance = None # destroy the instance
363 @unittest.skip("Remote Vpp Test Case Class")
364 class RemoteVppTestCase(VppTestCase):
365 """ Re-use VppTestCase to create remote VPP segment
371 # fork new process before client connects to VPP
372 cls.remote_test = RemoteClass(RemoteVppTestCase)
374 # start remote process
375 cls.remote_test.start_remote()
377 # set up your test case
378 super(MyTestCase, cls).setUpClass()
381 cls.remote_test.setUpClass(cls.tempdir)
384 def tearDownClass(cls):
385 # tear down remote test
386 cls.remote_test.tearDownClass()
388 # stop remote process
389 cls.remote_test.quit_remote()
391 # tear down your test case
392 super(MyTestCase, cls).tearDownClass()
396 super(RemoteVppTestCase, self).__init__("emptyTest")
398 # Note: __del__ is a 'Finalizer" not a 'Destructor'.
399 # https://docs.python.org/3/reference/datamodel.html#object.__del__
401 if hasattr(self, "vpp"):
403 if self.vpp.returncode is None:
405 self.vpp.communicate()
408 def setUpClass(cls, tempdir):
409 # disable features unsupported in remote VPP
410 orig_env = dict(os.environ)
411 if 'STEP' in os.environ:
412 del os.environ['STEP']
413 if 'DEBUG' in os.environ:
414 del os.environ['DEBUG']
415 cls.tempdir_prefix = os.path.basename(tempdir) + "/"
416 super(RemoteVppTestCase, cls).setUpClass()
417 os.environ = orig_env
420 def tearDownClass(cls):
421 super(RemoteVppTestCase, cls).tearDownClass()
423 @unittest.skip("Empty test")
428 def setTestFunctionInfo(self, name, doc):
430 Store the name and documentation string of currently executed test
431 in the main VPP for logging purposes.
433 self._testMethodName = name
434 self._testMethodDoc = doc