1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz runtime.

     5

     6

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     7

# Copyright (C) 2017: Andrey Skvortsov

     8

# Copyright (C) 2018: Edouard TISSERANT

     9

    10

# See COPYING file for copyrights details.

    11

    12

from __future__ import absolute_import

    13

from __future__ import print_function

    14

import sys

    15

import os

    16

    17

import Pyro

    18

import Pyro.core as pyro

    19

import runtime

    20

from runtime.ServicePublisher import ServicePublisher

    21

    22

    23

class PyroServer(object):

    24

    def __init__(self, servicename, ip_addr, port):

    25

        self.continueloop = True

    26

        self.daemon = None

    27

        self.servicename = servicename

    28

        self.ip_addr = ip_addr

    29

        self.port = port

    30

        self.servicepublisher = None

    31

        self.piper, self.pipew = None, None

    32

    33

    def _to_be_published(self):

    34

        return self.servicename is not None and \

    35

               self.ip_addr not in ["", "localhost", "127.0.0.1"]

    36

    37

    def PrintServerInfo(self):

    38

        print(_("Pyro port :"), self.port)

    39

    40

        if self._to_be_published():

    41

            print(_("Publishing service on local network"))

    42

    43

        sys.stdout.flush()

    44

    45

    def PyroLoop(self, when_ready):

    46

        if self._to_be_published():

    47

            self.Publish()

    48

    49

        while self.continueloop:

    50

            Pyro.config.PYRO_MULTITHREADED = 0

    51

            pyro.initServer()

    52

            self.daemon = pyro.Daemon(host=self.ip_addr, port=self.port)

    53

    54

            # pyro never frees memory after connection close if no timeout set

    55

            # taking too small timeout value may cause

    56

            # unwanted diconnection when IDE is kept busy for long periods

    57

            self.daemon.setTimeout(60)

    58

    59

            pyro_obj = Pyro.core.ObjBase()

    60

            pyro_obj.delegateTo(runtime.GetPLCObjectSingleton())

    61

    62

            self.daemon.connect(pyro_obj, "PLCObject")

    63

    64

            when_ready()

    65

    66

            # "pipe to self" trick to to accelerate runtime shutdown 

    67

            # instead of waiting for arbitrary pyro timeout.

    68

            others = []

    69

            if not sys.platform.startswith('win'):

    70

                self.piper, self.pipew = os.pipe()

    71

                others.append(self.piper)

    72

    73

            self.daemon.requestLoop(others=others, callback=lambda x: None)

    74

            self.piper, self.pipew = None, None

    75

            if hasattr(self, 'sock'):

    76

                self.daemon.sock.close()

    77

        self.Unpublish()

    78

    79

    def Restart(self):

    80

        self.daemon.shutdown(True)

    81

    82

    def Quit(self):

    83

        self.continueloop = False

    84

        self.daemon.shutdown(True)

    85

        self.daemon.closedown()

    86

        if not sys.platform.startswith('win'):

    87

            if self.pipew is not None:

    88

                os.write(self.pipew, "goodbye")

    89

    90

    def Publish(self):

    91

        self.servicepublisher = ServicePublisher("PYRO")

    92

        self.servicepublisher.RegisterService(self.servicename,

    93

                                              self.ip_addr, self.port)

    94

    95

    def Unpublish(self):

    96

        if self.servicepublisher is not None:

    97

            self.servicepublisher.UnRegisterService()

    98

            self.servicepublisher = None