#!/usr/bin/env python
import os
import unittest
import inspect
from multiprocessing import Process, Pipe
from pickle import dumps, PicklingError
from framework import VppTestCase
class SerializableClassCopy(object):
"""
Empty class used as a basis for a serializable copy of another class.
"""
pass
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] == '_':
raise AttributeError
self._path.append(attr)
return self
def __setattr__(self, attr, val):
if attr[0] == '_':
super(RemoteClassAttr, self).__setattr__(attr, val)
return
self._path.append(attr)
self._remote._remote_exec(RemoteClass.SETATTR, self.path_to_str(),
True, value=val)
def __call__(self, *args, **kwargs):
return self._remote._remote_exec(RemoteClass.CALL, self.path_to_str(),
True, *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')