#!/usr/bin/env python3
import inspect
import os
import reprlib
import unittest
from framework import VppTestCase
from multiprocessing import Process, Pipe
from pickle import dumps
import sys
from enum import IntEnum, IntFlag
class SerializableClassCopy(object):
"""
Empty class used as a basis for a serializable copy of another class.
"""
pass
def __repr__(self):
return '<SerializableClassCopy dict=%s>' % self.__dict__
class RemoteClassAttr(object):
"""
Wrapper around attribute of a remotely executed class.
"""
def __init__(self, remote, attr):
self._path = [attr] if attr else []
self._remote = remote
def path_to_str(self):
return '.'.join(self._path)
def get_remote_value(self):
return self._remote._remote_exec(RemoteClass.GET, self.path_to_str())
def __repr__(self):
return self._remote._remote_exec(RemoteClass.REPR, self.path_to_str())
def __str__(self):
return self._remote._remote_exec(RemoteClass.STR, self.path_to_str())
def __getattr__(self, attr):
if attr[0] == '_':
if not (attr.startswith('__') and attr.endswith('__')):
raise AttributeError('tried to get private attribute: %s ',
attr)
self._path.append(attr)
return self
def __setattr__(self, attr, val):
if attr[0] == '_':
if not (attr.startswith('__') and attr.endswith('__')):
super(RemoteClassAttr, self).__setattr__(attr, val)
return
self._path.append(attr)
self._remote._remote_exec(RemoteClass.SETATTR, self.path_to_str(),
value=val)
def __call__(self, *args, **kwargs):
return self._remote._remote_exec(RemoteClass.CALL, self.path_to_str(),
*args, **kwargs)
class RemoteClass(Process):
"""
This class can wrap around and adapt the interface of another class,
and then delegate its execution to a newly forked child process.
Usage:
# Create a remotely executed instance of MyClass
object = RemoteClass(MyClass, arg1='foo', arg2='bar')
object.start_remote()
# Access the object normally as if it was an instance of your class.
object.my_attribute = 20
print object.my_attribute
print object.my_method(object.my_attribute)
object.my_attribute.nested_attribute = 'test'
# If you need the value of a remote attribute, use .get_remote_value
method. This method is automatically called when needed in the context
of a remotely executed class. E.g.:
if (object.my_attribute.get_remote_value() > 20):
object.my_attribute2 = object.my_attribute
# Destroy the instance
object.quit_remote()
object.terminate()
"""
GET = 0 # Get attribute remotely
CALL = 1 # Call method remotely
SETATTR = 2 # Set attribute remotely
REPR = 3 # Get representation of a remote object
STR = 4 # Get string representation of a remote object
QUIT = 5 # Quit remote execution
PIPE_PARENT = 0 # Parent end of the pipe
PIPE_CHILD = 1 # Child end of the pipe
DEFAULT_TIMEOUT = 2 # default timeout for an operation to execute
def __init__(self, cls, *args, **kwargs):
super(RemoteClass, self).__init__()
self._cls = cls
self._args = args
self._kwargs = kwargs
self._timeout = RemoteClass.DEFAULT_TIMEOUT
self._pipe = Pipe() # pipe for input/output arguments
def __repr__(self):
return reprlib.repr(RemoteClassAttr(self, None))
def __str__(self):
return str(RemoteClassAttr(self, None))
def __call__(self, *args, **kwargs):
return self.RemoteClassAttr(self, None)()
def __getattr__(self, attr):
if attr[0] == '_' or not self.is_alive():
if not (attr.startswith('__') and attr.endswith('__')):
if hasattr(super(RemoteClass, self), '__getattr__'):
return super(RemoteClass, self).__getattr__(attr)
raise AttributeError('missing: %s', attr)
return RemoteClassAttr(self, attr)
def __setattr__(self, attr, val):
if attr[0] == '_' or not self.is_alive():
if not (attr.startswith('__') and attr.endswith('__')):
super(RemoteClass, self).__setattr__(attr, val)
return
setattr(RemoteClassAttr(self, None), attr, val)
def _remote_exec(self, op, path=None, *args, **kwargs):
"""
Execute given operation on a given, possibly nested, member remotely.
"""
# automatically resolve remote objects in the arguments
mutable_args = list(args)
for i, val in enumerate(mutable_args):
if isinstance(val, RemoteClass) or \
isinstance(val, RemoteClassAttr):
mutable_args[i] = val.get_remote_value()
args = tuple(mutable_args)
for key, val in kwargs.items():
if isinstance(val, RemoteClass) or \
isinstance(val, RemoteClassAttr):
kwargs[key] = val.get_remote_value()
# send request
args = self._make_serializable(args)
kwargs = self._make_serializable(kwargs)
self._pipe[RemoteClass.PIPE_PARENT].send((op, path, args, kwargs))
timeout = self._timeout
# adjust timeout specifically for the .sleep method
if path is not None and path.split('.')[-1] == 'sleep':
if args and isinstance(args[0], (long, int)):
timeout += args[0]
elif 'timeout' in kwargs:
timeout += kwargs['timeout']
if not self._pipe[RemoteClass.PIPE_PARENT].poll(timeout):
return None
try