How to use the powerapi.actor.Actor function in powerapi

# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import time

from multiprocessing import Queue
from mock import Mock

import pytest

from powerapi.message import PoisonPillMessage, StartMessage, OKMessage, ErrorMessage
from powerapi.actor import Actor, NotConnectedException

class FakeActor(Actor):

    def __init__(self, name, *args, queue=None, **kwargs):
        self.q = queue
        self.logger = Mock()
        self.logger.info = Mock()
        self.name = name
        self.socket_interface = Mock()
        self.q.put((name, args, kwargs))
        self.alive = False

    def connect_data(self):
        pass

    def connect_control(self):
        pass

OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""

import pytest
import zmq
from mock import Mock 
from powerapi.actor import Actor, Supervisor, ActorInitError, State
from powerapi.actor import SocketInterface, ActorAlreadySupervisedException
from powerapi.message import OKMessage, ErrorMessage, StartMessage

#########
# Utils #
#########

class FakeActor(Actor):

    def __init__(self):
        Actor.__init__(self, 'test_supervisor')
        self.state = State(Mock())
        self.send_msg = []
        self.alive = False

    def is_alive(self):
        return self.alive

    def kill(self):
        self.alive = False

    def join(self):
        pass

"""

import logging
import pytest
from mock import Mock
import setproctitle

from powerapi.message import UnknowMessageTypeException, PoisonPillMessage
from powerapi.actor import Actor, State
from powerapi.handler import PoisonPillMessageHandler


ACTOR_NAME = "dummy_actor"
LOG_LEVEL = logging.NOTSET

class DummyActor(Actor):

    def __init__(self, name=ACTOR_NAME):
        Actor.__init__(self, name, level_logger=LOG_LEVEL)

    def setup(self):
        self.add_handler(PoisonPillMessage, PoisonPillMessageHandler(self.state))


@pytest.fixture()
def dummy_actor_mocked():
    """ Return a mocked dummy actor"""
    actor = DummyActor()
    actor._signal_handler_setup = Mock()
    actor.state = Mock()
    actor.socket_interface = Mock()
    actor.socket_interface.send_control = Mock()

"""
        :param BaseDB database: Database for saving data.
        """
        State.__init__(self, actor)

        #: (BaseDB): Database for saving data.
        self.database = database

        #: (Report): Type of the report that the pusher handle.
        self.report_model = report_model

        #: (Dict): Buffer data.
        self.buffer = []


class PusherActor(Actor):
    """
    PusherActor class

    The Pusher allow to save Report sent by Formula.
    """

    def __init__(self, name, report_model, database, level_logger=logging.WARNING, timeout=1000, delay=100, max_size=50):
        """
        :param str name: Pusher name.
        :param Report report_model: ReportModel
        :param BaseDB database: Database use for saving data.
        :param int level_logger: Define the level of the logger
        :param int delay: number of ms before message containing in the buffer will be writen in database
        :param int max_size: maximum of message that the buffer can store before write them in database
        """
        Actor.__init__(self, name, level_logger, timeout)

def __init__(self, name, database, report_filter, report_model, stream_mode=False, level_logger=logging.WARNING,
                 timeout=0, timeout_puller=100):
        """
        :param str name: Actor name.
        :param BaseDB database: Allow to interact with a Database.
        :param Filter report_filter: Filter of the Puller.
        :param int level_logger: Define the level of the logger
        :param int tiemout_puller: (require stream mode) time (in ms) between two database reading
        """

        Actor.__init__(self, name, level_logger, timeout)
        #: (State): Actor State.
        self.state = PullerState(self, database, report_filter, report_model, stream_mode, timeout_puller)

def __init__(self, name, pushers: Dict[str, PusherActor], level_logger=logging.WARNING, timeout=None):
        """
        Initialize a new Formula actor.
        :param name: Actor name
        :param pushers: Pusher actors
        :param level_logger: Level of the logger
        :param timeout: Time in millisecond to wait for a message before calling the timeout handler
        """
        Actor.__init__(self, name, level_logger, timeout)
        self.state = FormulaState(self, pushers)

def setup(self):
        """
        Check if there is a primary group by rule. Set define
        StartMessage, PoisonPillMessage and Report handlers
        """
        Actor.setup(self)
        if self.state.route_table.primary_dispatch_rule is None:
            raise NoPrimaryDispatchRuleRuleException()

        self.add_handler(Report, FormulaDispatcherReportHandler(self.state))
        self.add_handler(PoisonPillMessage, DispatcherPoisonPillMessageHandler(self.state))
        self.add_handler(StartMessage, StartHandler(self.state))