pyre-gevent 0.2.3.dev3__tar.gz → 0.3.0__tar.gz

{pyre-gevent-0.2.3.dev3/pyre_gevent.egg-info → pyre-gevent-0.3.0}/PKG-INFO

@@ -1,16 +1,15 @@
-Metadata-Version: 1.2
+Metadata-Version: 2.1
 Name: pyre-gevent
-Version: 0.2.3.dev3
+Version: 0.3.0
 Summary: Python ZRE implementation (green version)
 Home-page: http://www.github.com/tangb/pyre-gevent/
 Author: Arnaud Loonstra
 Author-email: arnaud@sphaero.org
 Maintainer: Tanguy Bonneau
 Maintainer-email: tanguy.bonneau@gmail.com
-License: UNKNOWN
-Description: UNKNOWN
-Platform: UNKNOWN
 Requires: pyzmq
 Requires: ipaddress
 Requires: netaddr
-Requires: netifaces
+Requires: netifaces2
+License-File: LICENSE
+License-File: AUTHORS

pyre-gevent-0.3.0/pyre_gevent/__init__.py

@@ -0,0 +1,8 @@
+import re
+
+__all__ = ["pyre", "zbeacon", "zhelper"]
+__version__ = "0.3.0"
+__version_info__ = tuple(int(v) for v in re.sub("[a-zA-Z]", "", __version__).split("."))
+
+from .pyre import Pyre
+from .pyre_event import PyreEvent

{pyre-gevent-0.2.3.dev3 → pyre-gevent-0.3.0}/pyre_gevent/pyre.py

@@ -39,7 +39,7 @@ class Pyre(object):
         """
         super(Pyre, self).__init__(*args, **kwargs)
         ctx = kwargs.get('ctx')
-        if ctx == None:
+        if ctx is None:
             ctx = zmq.Context()
         self._ctx = ctx
         self._uuid = None

{pyre-gevent-0.2.3.dev3 → pyre-gevent-0.3.0}/pyre_gevent/pyre_event.py

@@ -27,7 +27,7 @@ class PyreEvent(object):
         if self.type == "ENTER":
             self.headers = json.loads(incoming.pop(0).decode('utf-8'))
             self.peer_addr = incoming.pop(0).decode('utf-8')
-        elif self.type == "JOIN" or self.type == "LEAVE":
+        elif self.type in ["JOIN", "LEAVE"]:
             self.group = incoming.pop(0).decode('utf-8')
         elif self.type == "WHISPER":
             self.msg = incoming
@@ -44,9 +44,7 @@ class PyreEvent(object):
         Returns:
             str: Header value
         """
-        if self.headers and name in self.headers:
-            return self.headers[name]
-        return None
+        return self.headers[name] if self.headers and name in self.headers else None
 
     @property
     def peer_uuid(self):

{pyre-gevent-0.2.3.dev3 → pyre-gevent-0.3.0}/pyre_gevent/pyre_node.py

@@ -301,7 +301,8 @@ class PyreNode(object):
             logger.warning("Unkown Node API command: {0}".format(command))
 
     def purge_peer(self, peer, endpoint):
-        if (peer.get_endpoint() == endpoint):
+        if peer.get_endpoint() == endpoint:
+            self.remove_peer(peer)
             peer.disconnect()
             logger.debug("Purge peer: {0}{1}".format(peer,endpoint))
 
@@ -410,7 +411,7 @@ class PyreNode(object):
 
         # Ignore command if peer isn't ready
         if not peer or not peer.get_ready():
-            logger.warning("Peer {0} isn't ready".format(peer))
+            logger.debug("Peer {0} isn't ready".format(peer))
             return
 
         if peer.messages_lost(zmsg):
@@ -530,8 +531,7 @@ class PyreNode(object):
         reap_at = time.time() + REAP_INTERVAL
         while not self._terminated:
             timeout = reap_at - time.time()
-            if timeout < 0:
-                timeout = 0
+            timeout = max(timeout, 0)
             items = dict(self.poller.poll(timeout * 1000))
 
             if self._pipe in items and items[self._pipe] == zmq.POLLIN:

{pyre-gevent-0.2.3.dev3 → pyre-gevent-0.3.0}/pyre_gevent/zbeacon.py

@@ -1,4 +1,3 @@
-
 # ======================================================================
 #  zbeacon - LAN discovery and presence
 #
@@ -38,26 +37,30 @@ import netaddr
 logger = logging.getLogger(__name__)
 
 INTERVAL_DFLT = 1.0
-BEACON_MAX = 255      # Max size of beacon data
-MULTICAST_GRP = '225.25.25.25'
+BEACON_MAX = 255  # Max size of beacon data
+MULTICAST_GRP = "225.25.25.25"
+ENETDOWN = 50  # socket error, network is down
+ENETUNREACH = 51  # socket error, network unreachable
 
 
 class ZBeacon(object):
 
     def __init__(self, ctx, pipe, *args, **kwargs):
-        self.ctx = ctx                #  ZMQ context
-        self.pipe = pipe              #  Actor command pipe
-        self.udpsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
-                                      #  UDP socket for send/recv
-        self.port_nbr = 0             #  UDP port number we work on
-        self.interval = INTERVAL_DFLT #  Beacon broadcast interval
-        self.ping_at = 0              #  Next broadcast time
-        self.transmit = None          #  Beacon transmit data
-        self.filter = b""             #  Beacon filter data
-
-        self.terminated = False       #  Did caller ask us to quit?
-        self.verbose = False          #  Verbose logging enabled?
-        self.hostname = ""            #  Saved host name
+        self.ctx = ctx  #  ZMQ context
+        self.pipe = pipe  #  Actor command pipe
+        self.udpsock = socket.socket(
+            socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP
+        )
+        #  UDP socket for send/recv
+        self.port_nbr = 0  #  UDP port number we work on
+        self.interval = INTERVAL_DFLT  #  Beacon broadcast interval
+        self.ping_at = 0  #  Next broadcast time
+        self.transmit = None  #  Beacon transmit data
+        self.filter = b""  #  Beacon filter data
+
+        self.terminated = False  #  Did caller ask us to quit?
+        self.verbose = False  #  Verbose logging enabled?
+        self.hostname = ""  #  Saved host name
 
         self.address = None
         self.mac = None
@@ -71,23 +74,25 @@ class ZBeacon(object):
             self.udpsock.close()
 
     def prepare_udp(self, interface_name=None):
-        self._prepare_socket(interface_name)
+        try:
+            self._prepare_socket(interface_name)
+        except ValueError:
+            logger.exception("Error preparing socket:")
+            return
         try:
             self.udpsock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
             self.udpsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 
             #  On some platforms we have to ask to reuse the port
             try:
-                self.udpsock.setsockopt(socket.SOL_SOCKET,
-                                        socket.SO_REUSEPORT, 1)
+                self.udpsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
 
             except AttributeError:
                 pass
 
             if self.broadcast_address.is_multicast:
                 # TTL
-                self.udpsock.setsockopt(socket.IPPROTO_IP,
-                                        socket.IP_MULTICAST_TTL, 2)
+                self.udpsock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
 
                 # TODO: This should only be used if we do not have inproc method!
                 self.udpsock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_LOOP, 1)
@@ -115,48 +120,63 @@ class ZBeacon(object):
                 self.udpsock.bind(("", self.port_nbr))
 
                 group = socket.inet_aton("{0}".format(self.broadcast_address))
-                mreq = struct.pack('4sl', group, socket.INADDR_ANY)
+                mreq = struct.pack("4sl", group, socket.INADDR_ANY)
 
-                self.udpsock.setsockopt(socket.SOL_IP,
-                                        socket.IP_ADD_MEMBERSHIP, mreq)
+                self.udpsock.setsockopt(socket.SOL_IP, socket.IP_ADD_MEMBERSHIP, mreq)
 
             else:
                 # Platform specifics
                 if platform.startswith("linux"):
                     # on linux we bind to the broadcast address and send to
                     # the broadcast address
-                    self.udpsock.bind((str(self.broadcast_address),
-                                       self.port_nbr))
+                    self.udpsock.bind((str(self.broadcast_address), self.port_nbr))
                 else:
                     self.udpsock.bind(("", self.port_nbr))
 
-                logger.debug("Set up a broadcast beacon to {0}:{1}".format(self.broadcast_address, self.port_nbr))
+                logger.debug(
+                    "Set up a broadcast beacon to {0}:{1}".format(
+                        self.broadcast_address, self.port_nbr
+                    )
+                )
         except socket.error:
-            logger.exception("Initializing of {0} raised an exception".format(self.__class__.__name__))
+            logger.exception(
+                "Initializing of {0} raised an exception".format(
+                    self.__class__.__name__
+                )
+            )
 
     def _prepare_socket(self, interface_name=None):
         netinf = zhelper.get_ifaddrs()
         logger.debug("Available interfaces: {0}".format(netinf))
 
-        #get default gateway interface
+        # get default gateway interface
         default_interface_names = []
         netifaces_default_interface_names = []
         gateways = netifaces.gateways()
         logger.debug("Gateways: {0}".format(gateways))
         if netifaces.AF_INET in gateways:
             for address, interface, is_default in gateways[netifaces.AF_INET]:
-                #fix for windows (netifaces.gateway() returns adapter name instead of interface name)
+                # fix for windows (netifaces.gateway() returns adapter name instead of interface name)
                 if platform.startswith("win"):
                     netifaces_default_interface_names.append(interface)
                     for iface in netinf:
                         for name, data in iface.items():
-                            if netifaces.AF_INET in data and data[netifaces.AF_INET]['adapter']==interface:
+                            if (
+                                netifaces.AF_INET in data
+                                and data[netifaces.AF_INET]["adapter"] == interface
+                            ):
                                 default_interface_names.append(name)
                 else:
                     default_interface_names.append(interface)
-                    
-            logger.debug('Default interface names "{0}"'.format(list(default_interface_names)))
-            logger.debug('Netifaces default interface names "{0}"'.format(list(netifaces_default_interface_names)))
+
+            logger.debug(
+                "Default interface names '{0}'".format(list(default_interface_names))
+            )
+            logger.debug(
+                "Netifaces default interface names '{0}'".format(
+                    list(netifaces_default_interface_names)
+                )
+            )
 
         for iface in netinf:
             # Loop over the interfaces and their settings to try to find the broadcast address.
@@ -166,39 +186,53 @@ class ZBeacon(object):
                 if interface_name and interface_name != name:
                     continue
 
-                #Interface of default route found, skip other ones
-                #This trick allows to skip invalid interfaces like docker ones.
-                if len(default_interface_names)>0 and name not in default_interface_names:
-                    logger.debug('Interface "{0}" is not interface of default route'.format(name))
+                # Interface of default route found, skip other ones
+                # This trick allows to skip invalid interfaces like docker ones.
+                if (
+                    len(default_interface_names) > 0
+                    and name not in default_interface_names
+                ):
+                    logger.debug(
+                        "Interface '{0}' is not interface of default route".format(name)
+                    )
                     continue
 
-                logger.debug('Checking out interface "{0}".'.format(name))
+                logger.debug("Checking out interface '{0}'.".format(name))
 
-                #Get addr and netmask infos
+                # Get addr and netmask infos
                 data_2 = data.get(netifaces.AF_INET)
                 if not data_2:
-                    logger.debug('No data_2 found for interface "{0}".'.format(name))
+                    logger.debug("No data_2 found for interface '{0}'.".format(name))
                     continue
 
-                #get mac address infos
-                data_17 = data.get(netifaces.AF_LINK)
+                # get mac address infos
+                data_17 = data.get(netifaces.AF_PACKET)
                 if not data_17 and platform.startswith("win"):
-                    #last chance to get mac address on windows platform
-                    for netifaces_default_interface_name in netifaces_default_interface_names:
-                        ifaddresses = netifaces.ifaddresses(netifaces_default_interface_name)
-                        if netifaces.AF_LINK in ifaddresses and len(ifaddresses[netifaces.AF_LINK])>0:
-                            data_17 = ifaddresses[netifaces.AF_LINK][0]
+                    # last chance to get mac address on windows platform
+                    for (
+                        netifaces_default_interface_name
+                    ) in netifaces_default_interface_names:
+                        ifaddresses = netifaces.ifaddresses(
+                            netifaces_default_interface_name
+                        )
+                        if (
+                            netifaces.AF_PACKET in ifaddresses
+                            and len(ifaddresses[netifaces.AF_PACKET]) > 0
+                        ):
+                            data_17 = ifaddresses[netifaces.AF_PACKET][0]
                             break
                 if not data_17:
-                    logger.debug('No data_17 found for interface "{0}".'.format(name))
+                    logger.debug("No data_17 found for interface '{0}'.".format(name))
                     continue
 
                 address_str = data_2.get("addr")
                 netmask_str = data_2.get("netmask")
-                mac_str = data_17.get("addr")                
+                mac_str = data_17.get("addr")
 
                 if not address_str or not netmask_str:
-                    logger.debug('Address or netmask not found for interface "{0}".'.format(name))
+                    logger.debug(
+                        "Address or netmask not found for interface '{0}'.".format(name)
+                    )
                     continue
 
                 if isinstance(address_str, bytes):
@@ -210,10 +244,24 @@ class ZBeacon(object):
                 if isinstance(mac_str, bytes):
                     mac_str = mac_str.decode("utf8")
 
-                #keep only private interface
+                # keep only private interface
                 ip_address = netaddr.IPAddress(address_str)
-                if ip_address and not ip_address.is_private():
-                    logger.debug('Interface "{0}" refers to public ip address, drop it.'.format(name))
+                # handle netaddr breaking changes
+                if netaddr.__version__.startswith("0."):
+                    # is_private does not exist anymore on new IpAddress lib version
+                    # pylint: disable=no-member
+                    ip_is_private = ip_address.is_private()
+                else:
+                    ip_is_private = (
+                        ip_address.is_ipv4_private_use()
+                        or ip_address.is_ipv6_unique_local()
+                    )
+                if ip_address and not ip_is_private():
+                    logger.debug(
+                        "Interface '{0}' refers to public ip address, drop it.".format(
+                            name
+                        )
+                    )
                     continue
 
                 interface_string = "{0}/{1}".format(address_str, netmask_str)
@@ -221,11 +269,11 @@ class ZBeacon(object):
                 interface = ipaddress.ip_interface(u(interface_string))
 
                 if interface.is_loopback:
-                    logger.debug('Interface "{0}" is a loopback device.'.format(name))
+                    logger.debug("Interface {0} is a loopback device.".format(name))
                     continue
 
                 if interface.is_link_local:
-                    logger.debug('Interface "{0}" is a link-local device.'.format(name))
+                    logger.debug("Interface {0} is a link-local device.".format(name))
                     continue
 
                 self.address = interface.ip
@@ -236,17 +284,17 @@ class ZBeacon(object):
 
                 if self.address:
                     break
-            
+
             if self.address:
                 break
 
         logger.debug("Finished scanning interfaces.")
 
         if not self.address:
-            self.network_address = ipaddress.IPv4Address(u('127.0.0.1'))
+            self.network_address = ipaddress.IPv4Address(u("127.0.0.1"))
             self.broadcast_address = ipaddress.IPv4Address(u(MULTICAST_GRP))
-            self.interface_name = 'loopback'
-            self.address = u('127.0.0.1')
+            self.interface_name = "loopback"
+            self.address = u("127.0.0.1")
             self.mac = None
 
         logger.debug("Address: {0}".format(self.address))
@@ -263,9 +311,9 @@ class ZBeacon(object):
     def handle_pipe(self):
         #  Get just the commands off the pipe
         request = self.pipe.recv_multipart()
-        command = request.pop(0).decode('UTF-8')
+        command = request.pop(0).decode("UTF-8")
         if not command:
-            return -1                  #  Interrupted
+            return -1  #  Interrupted
 
         if self.verbose:
             logger.debug("zbeacon: API command={0}".format(command))
@@ -276,10 +324,13 @@ class ZBeacon(object):
             # unpacking code from https://bit.ly/2qN3ZUz
             interface_data = request.pop(0)
 
-            (interface_name_len,), interface = struct.unpack('I', interface_data[:4]), interface_data[4:]
-            interface = interface.decode('UTF-8')
+            (interface_name_len,), interface = (
+                struct.unpack("I", interface_data[:4]),
+                interface_data[4:],
+            )
+            interface = interface.decode("UTF-8")
 
-            port = struct.unpack('I', request.pop(0))[0]
+            port = struct.unpack("I", request.pop(0))[0]
             self.configure(interface, port)
         elif command == "PUBLISH":
             self.transmit = request.pop(0)
@@ -312,8 +363,8 @@ class ZBeacon(object):
         is_valid = False
         if self.filter is not None:
             if len(self.filter) <= len(frame):
-                match_data = frame[:len(self.filter)]
-                if (match_data == self.filter):
+                match_data = frame[: len(self.filter)]
+                if match_data == self.filter:
                     is_valid = True
 
         #  If valid, discard our own broadcasts, which UDP echoes to us
@@ -328,13 +379,27 @@ class ZBeacon(object):
 
     def send_beacon(self):
         try:
-            self.udpsock.sendto(self.transmit, (str(self.broadcast_address),
-                                                self.port_nbr))
-        except (OSError, socket.error):
-            logger.debug("Network seems gone, restarting zbeacon udp connection")
-            #restart socket
-            time.sleep(1.0)
-            self.prepare_udp()
+            self.udpsock.sendto(
+                self.transmit, (str(self.broadcast_address), self.port_nbr)
+            )
+
+        except OSError as e:
+
+            # network down, just wait, it could come back up again.
+            # socket call errors 50 and 51 relate to the network being
+            # down or unreachable, the recommended action to take is to
+            # try again so we don't terminate in these cases.
+            if e.errno in [ENETDOWN, ENETUNREACH]:
+                pass
+
+            # all other cases, we'll terminate
+            else:
+                logger.debug("Network seems gone, exiting zbeacon")
+                self.terminated = True
+
+        except socket.error:
+            logger.debug("Network seems gone, exiting zbeacon")
+            self.terminated = True
 
     def run(self):
         # Signal actor successfully initialized
@@ -354,7 +419,10 @@ class ZBeacon(object):
             items = dict(self.poller.poll(timeout * 1000))
             if self.pipe in items and items[self.pipe] == zmq.POLLIN:
                 self.handle_pipe()
-            if self.udpsock.fileno() in items and items[self.udpsock.fileno()] == zmq.POLLIN:
+            if (
+                self.udpsock.fileno() in items
+                and items[self.udpsock.fileno()] == zmq.POLLIN
+            ):
                 self.handle_udp()
 
             if self.transmit and time.time() >= self.ping_at:
@@ -362,18 +430,20 @@ class ZBeacon(object):
                 self.ping_at = time.time() + self.interval
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     import zmq
     import struct
     import time
+
     speaker = ZActor(zmq.Context(), ZBeacon)
     speaker.send_unicode("VERBOSE")
     speaker.send_unicode("CONFIGURE", zmq.SNDMORE)
     speaker.send(struct.pack("I", 9999))
     speaker.send_unicode("PUBLISH", zmq.SNDMORE)
     import uuid
-    transmit = struct.pack('cccb16sH', b'Z', b'R', b'E',
-                           1, uuid.uuid4().bytes,
-                           socket.htons(1300))
+
+    transmit = struct.pack(
+        "cccb16sH", b"Z", b"R", b"E", 1, uuid.uuid4().bytes, socket.htons(1300)
+    )
     speaker.send(transmit)
     speaker.destroy()

{pyre-gevent-0.2.3.dev3 → pyre-gevent-0.3.0}/pyre_gevent/zre_msg.py

@@ -68,7 +68,7 @@ class ZreMsg(object):
     def recv(self, input_socket):
         # If we're reading from a ROUTER socket, get address
         frames = input_socket.recv_multipart()
-        if input_socket.socket_type == zmq.ROUTER:
+        if input_socket.type == zmq.ROUTER:
             self.address = frames.pop(0)
             # we drop the first byte: TODO ref!
             try:
@@ -181,7 +181,7 @@ class ZreMsg(object):
             logger.debug("Message type {0} unknown".format(self.id))
 
         # If we're sending to a ROUTER, we send the address first
-        if output_socket.socket_type == zmq.ROUTER:
+        if output_socket.type == zmq.ROUTER:
             output_socket.send(self.address.bytes, zmq.SNDMORE)
         # Now send the data frame
         if (self.content):
@@ -414,9 +414,7 @@ class ZreMsg(object):
         group_len = self._get_number4()
         #print("needle is at: %i"% self._needle )
         #print("grouplen: ", group_len)
-        self.groups = []
-        for x in range(group_len):
-            self.groups.append(self._get_long_string())
+        self.groups = [self._get_long_string() for _ in range(group_len)]
         #print(self.groups)
         #print("post_group: needle is at: %i"% self._needle )
         self.status = self._get_number1()

{pyre-gevent-0.2.3.dev3 → pyre-gevent-0.3.0/pyre_gevent.egg-info}/PKG-INFO

@@ -1,16 +1,15 @@
-Metadata-Version: 1.2
+Metadata-Version: 2.1
 Name: pyre-gevent
-Version: 0.2.3.dev3
+Version: 0.3.0
 Summary: Python ZRE implementation (green version)
 Home-page: http://www.github.com/tangb/pyre-gevent/
 Author: Arnaud Loonstra
 Author-email: arnaud@sphaero.org
 Maintainer: Tanguy Bonneau
 Maintainer-email: tanguy.bonneau@gmail.com
-License: UNKNOWN
-Description: UNKNOWN
-Platform: UNKNOWN
 Requires: pyzmq
 Requires: ipaddress
 Requires: netaddr
-Requires: netifaces
+Requires: netifaces2
+License-File: LICENSE
+License-File: AUTHORS

{pyre-gevent-0.2.3.dev3 → pyre-gevent-0.3.0}/pyre_gevent.egg-info/SOURCES.txt

@@ -19,4 +19,9 @@ pyre_gevent.egg-info/PKG-INFO
 pyre_gevent.egg-info/SOURCES.txt
 pyre_gevent.egg-info/dependency_links.txt
 pyre_gevent.egg-info/requires.txt
-pyre_gevent.egg-info/top_level.txt
+pyre_gevent.egg-info/top_level.txt
+tests/test_network_disconnect.py
+tests/test_pyre.py
+tests/test_zactor.py
+tests/test_zbeacon.py
+tests/test_zhelper.py

{pyre-gevent-0.2.3.dev3 → pyre-gevent-0.3.0}/pyre_gevent.egg-info/requires.txt

@@ -1,4 +1,4 @@
-pyzmq
 ipaddress
 netaddr
-netifaces
+netifaces2
+pyzmq

{pyre-gevent-0.2.3.dev3 → pyre-gevent-0.3.0}/setup.py

@@ -37,6 +37,6 @@ setup(
         url='http://www.github.com/tangb/pyre-gevent/',
         packages=['pyre_gevent'],
         include_package_data=True,
-        requires=['pyzmq', 'ipaddress', 'netaddr', 'netifaces'],
-        install_requires=['pyzmq', 'ipaddress', 'netaddr', 'netifaces'],
+        requires=['pyzmq', 'ipaddress', 'netaddr', 'netifaces2'],
+        install_requires=['pyzmq', 'ipaddress', 'netaddr', 'netifaces2'],
 )

pyre-gevent-0.3.0/tests/test_network_disconnect.py

@@ -0,0 +1,81 @@
+import os
+import time
+import logging
+import subprocess
+import pyre
+
+
+# The test needs the device name of the active network interface.
+# The device name can be found under `DEVICE` column after running `nmcli c`.
+# The device name should be set to the variable bellow, or as the `DEVICE` env variable.
+NMCLI_DEVICE: str = None
+
+NMCLI_LINETERMINATOR = "\n"
+NMCLI_DELIMITER = "  "
+
+
+logger = logging.getLogger(__name__)
+
+
+def _network_device() -> str:
+    return NMCLI_DEVICE or os.environ.get("DEVICE", None)
+
+
+def _network_device_is_enabled(device: str) -> bool:
+    result = subprocess.run(["nmcli", "c"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    assert result.returncode == 0, result.stderr.decode("ascii")
+    output = result.stdout.decode("ascii")
+    rows = [[val.strip() for val in row.split(NMCLI_DELIMITER)  if val.strip()] for row in output.split(NMCLI_LINETERMINATOR) if row.strip()]
+    head, rows = rows[0], rows[1:]
+    devices = [dict(zip(head, row)) for row in rows]
+    return any(d["DEVICE"] == device for d in devices)
+
+
+def _network_device_enable(device: str, enable: bool):
+    if _network_device_is_enabled(device) == enable:
+        return
+    cmd = 'connect' if enable else 'disconnect'
+    result = subprocess.run(["nmcli", "d", cmd, f"{device}"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    assert result.returncode == 0, result.stderr.decode("ascii")
+    time.sleep(3)
+    while _network_device_is_enabled(device) != enable:
+        pass
+    logger.debug("Device \"{device}\" was {cmd}ed")
+
+
+def test_network_disconnect(group="best-group"):
+
+    device = _network_device()
+
+    if device is None:
+        logger.warn("Skipping test. Please specify an active network interface to use for testing.")
+        return
+
+    _network_device_enable(device, enable=True)
+
+    try:
+        pyre_node = pyre.Pyre(name="foo")
+        pyre_node.join(group)
+        pyre_node.start()
+        logger.debug("Pyre started")
+
+        _network_device_enable(device, enable=False)
+
+        pyre_node.leave(group)
+        logger.debug("Pyre left group")
+
+        pyre_node.stop()
+        logger.debug("Pyre stopped")
+
+        del pyre_node
+        logger.debug("Pyre destroyed")
+
+    except KeyboardInterrupt:
+        pass
+
+    finally:
+        _network_device_enable(device, enable=True)
+
+
+if __name__ == '__main__':
+    test_network_disconnect()

pyre-gevent-0.3.0/tests/test_pyre.py

@@ -0,0 +1,178 @@
+import unittest
+import pyre
+import zmq
+import time
+import logging
+import sys
+
+
+if sys.version.startswith('3'):
+    unicode = str
+
+
+class PyreTest(unittest.TestCase):
+    def setUp(self, *args, **kwargs):
+        ctx = zmq.Context()
+        self.node1 = pyre.Pyre("node1", ctx=ctx)
+        self.node1.set_header("X-TEST", "1")
+        self.node2 = pyre.Pyre("node2", ctx=ctx)
+        self.node2.set_header("X-TEST", "1")
+        self.node1.start()
+        self.node2.start()
+        # give time for nodes to exchange
+        time.sleep(1)
+    # end setUp
+
+    def tearDown(self):
+        self.node1.stop()
+        self.node2.stop()
+    # end tearDown
+
+    def test_get_name(self):
+        self.assertEqual("node1", self.node1.name())
+        self.assertEqual("node2", self.node2.name())
+    # end test_get_name
+
+    def test_get_peers(self):
+        id1 = self.node1.uuid()
+        peers = self.node2.peers()
+
+        self.assertIsInstance(peers, list)
+        self.assertIn(id1, peers)
+    # end test_get_peers
+
+    def test_get_peers_by_group(self):
+        id1 = self.node1.uuid()
+        self.node1.join("TEST")
+        # pyre works asynchronous so give some time to let changes disperse
+        time.sleep(0.5)
+
+        peers = self.node2.peers_by_group("TEST")
+        self.node1.leave("TEST")
+
+        self.assertIsInstance(peers, list)
+        self.assertIn(id1, peers)
+    # end test_get_peers
+
+    def test_get_peer_address(self):
+        id1 = self.node1.uuid()
+        id2 = self.node2.uuid()
+
+        self.assertIsInstance(self.node1.peer_address(id2), unicode)
+        self.assertIsInstance(self.node2.peer_address(id1), unicode)
+    # end test_get_peer_address
+
+    def test_peer_header_value(self):
+        id1 = self.node1.uuid()
+        id2 = self.node2.uuid()
+
+        self.assertEqual("1", self.node1.peer_header_value(id2, "X-TEST"))
+        self.assertEqual("1", self.node2.peer_header_value(id1, "X-TEST"))
+    # end test_get_peer_header_value
+
+    def test_get_own_groups(self):
+        self.node1.join("TEST")
+        self.node2.join("TEST")
+        # pyre works asynchronous so give some time to let changes disperse
+        time.sleep(0.5)
+
+        self.assertIn("TEST", self.node1.own_groups())
+        self.assertIn("TEST", self.node2.own_groups())
+    # end test_get_own_groups
+
+    def test_join_leave_msg(self):
+        msg = self.node1.recv()
+        self.assertEqual(msg[0], b'ENTER')
+        msg = self.node2.recv()
+        self.assertEqual(msg[0], b'ENTER')
+        self.node1.join("TEST")
+        self.node2.join("TEST")
+        msg = self.node1.recv()
+        self.assertEqual(msg[0], b'JOIN')
+        msg = self.node2.recv()
+        self.assertEqual(msg[0], b'JOIN')
+        self.node1.leave("TEST")
+        self.node2.leave("TEST")
+        msg = self.node1.recv()
+        self.assertEqual(msg[0], b'LEAVE')
+        msg = self.node2.recv()
+        self.assertEqual(msg[0], b'LEAVE')
+
+    def test_get_peer_groups(self):
+        self.node1.join("TEST")
+        self.node2.join("TEST")
+
+        # pyre works asynchronous so give some time to let changes disperse
+        time.sleep(0.5)
+
+        self.assertIn("TEST", self.node1.peer_groups())
+        self.assertIn("TEST", self.node2.peer_groups())
+    # end test_get_peer_groups
+
+    def test_whispers(self):
+        msg = self.node1.recv()
+        self.assertEqual(msg[0], b'ENTER')
+        msg = self.node2.recv()
+        self.assertEqual(msg[0], b'ENTER')
+        self.node1.whispers(self.node2.uuid(), "Hi")
+        msg = self.node2.recv()
+        self.assertEqual(b"WHISPER", msg[0])
+        self.assertEqual(self.node1.uuid().bytes, msg[1])
+        self.assertEqual(b"node1", msg[2])
+        self.assertEqual(b"Hi", msg[3])
+
+    def test_shouts(self):
+        msg = self.node1.recv()
+        self.assertEqual(msg[0], b'ENTER')
+        msg = self.node2.recv()
+        self.assertEqual(msg[0], b'ENTER')
+        self.node1.join("TEST")
+        self.node2.join("TEST")
+        msg = self.node1.recv()
+        self.assertEqual(msg[0], b'JOIN')
+        msg = self.node2.recv()
+        self.assertEqual(msg[0], b'JOIN')
+        self.node1.shouts("TEST", "Hi")
+        msg = self.node2.recv()
+        self.assertEqual(b"SHOUT", msg[0])
+        self.assertEqual(self.node1.uuid().bytes, msg[1])
+        self.assertEqual(b"node1", msg[2])
+        self.assertEqual(b"TEST", msg[3])
+        self.assertEqual(b"Hi", msg[4])
+
+    def test_shout(self):
+        msg = self.node1.recv()
+        self.assertEqual(msg[0], b'ENTER')
+        msg = self.node2.recv()
+        self.assertEqual(msg[0], b'ENTER')
+        self.node1.join("TEST")
+        self.node2.join("TEST")
+        msg = self.node1.recv()
+        self.assertEqual(msg[0], b'JOIN')
+        msg = self.node2.recv()
+        self.assertEqual(msg[0], b'JOIN')
+        self.node1.shout("TEST", b"Hi")
+        msg = self.node2.recv()
+        self.assertEqual(b"SHOUT", msg[0])
+        self.assertEqual(self.node1.uuid().bytes, msg[1])
+        self.assertEqual(b"node1", msg[2])
+        self.assertEqual(b"TEST", msg[3])
+        self.assertEqual(b"Hi", msg[4])
+
+    def test_zfinal(self):
+        global inst_count
+        inst_count = 1
+        self.assertTrue(True)
+    # end test_zfinal
+# end PyreTest
+
+if __name__ == '__main__':
+    inst_count = 0
+
+    logger = logging.getLogger("pyre")
+    logger.setLevel(logging.DEBUG)
+
+    try:
+        unittest.main()
+    except Exception as a:
+        print(a)

pyre-gevent-0.3.0/tests/test_zactor.py

@@ -0,0 +1,38 @@
+import unittest
+import zmq
+import logging
+from pyre import zactor
+from pyre.zactor import ZActor
+from pyre.zbeacon import ZBeacon
+
+class ZBeaconTest(unittest.TestCase):
+    
+    def setUp(self, *args, **kwargs):
+        ctx = zmq.Context()
+        self.actor = ZActor(ctx, zactor.echo_actor, "Hello, World")
+    # end setUp
+
+    def tearDown(self):
+        self.actor.destroy()
+    # end tearDown
+
+    def test_echo(self):
+        self.actor.send_multipart((b"ECHO", b"This is a string"))
+        msg = self.actor.recv()
+        self.assertEqual(b"This is a string", msg)
+# end ZActorTest
+
+
+if __name__ == '__main__':
+    #print(logging.Logger.manager.loggerDict)
+    logger = logging.getLogger()
+    logger.setLevel(logging.DEBUG)
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.DEBUG)
+    logger.addHandler(ch)
+    logging.getLogger("pyre.zactor").setLevel(logging.DEBUG)
+    
+    try:
+        unittest.main()
+    except Exception as a:
+        print(a)

pyre-gevent-0.3.0/tests/test_zbeacon.py

@@ -0,0 +1,82 @@
+import unittest
+#import pyre
+import zmq
+import time
+import struct
+import uuid
+import logging
+import socket
+from pyre.zactor import ZActor
+from pyre.zbeacon import ZBeacon
+
+class ZBeaconTest(unittest.TestCase):
+    
+    def setUp(self, *args, **kwargs):
+        ctx = zmq.Context()
+        ctx = zmq.Context()
+        # two beacon frames
+        self.transmit1 = struct.pack('cccb16sH', b'Z', b'R', b'E',
+                           1, uuid.uuid4().bytes,
+                           socket.htons(9999))
+        self.transmit2 = struct.pack('cccb16sH', b'Z', b'R', b'E',
+                           1, uuid.uuid4().bytes,
+                           socket.htons(9999))
+
+        self.node1 = ZActor(ctx, ZBeacon)
+        self.node1.send_unicode("VERBOSE")
+        self.node1.send_unicode("CONFIGURE", zmq.SNDMORE)
+        self.node1.send(struct.pack("I", 9999))
+        print("Hostname 1:", self.node1.recv_unicode())
+
+        self.node2 = ZActor(ctx, ZBeacon)
+        self.node2.send_unicode("VERBOSE")
+        self.node2.send_unicode("CONFIGURE", zmq.SNDMORE)
+        self.node2.send(struct.pack("I", 9999))
+        print("Hostname 2:", self.node2.recv_unicode())
+    # end setUp
+
+    def tearDown(self):
+        self.node1.destroy()
+        self.node2.destroy()
+    # end tearDown
+
+    def test_node1(self):
+        self.node1.send_unicode("PUBLISH", zmq.SNDMORE)
+        self.node1.send(self.transmit1)
+
+    def test_node2(self):
+        self.node2.send_unicode("PUBLISH", zmq.SNDMORE)
+        self.node2.send(self.transmit2)
+
+    def test_recv_beacon1(self):
+        self.node1.send_unicode("PUBLISH", zmq.SNDMORE)
+        self.node1.send(self.transmit1)
+        self.node2.send_unicode("PUBLISH", zmq.SNDMORE)
+        self.node2.send(self.transmit2)
+        req = self.node1.recv_multipart()
+        self.assertEqual(self.transmit2, req[1])
+    
+    def test_recv_beacon1(self):
+        self.node1.send_unicode("PUBLISH", zmq.SNDMORE)
+        self.node1.send(self.transmit1)
+        self.node2.send_unicode("PUBLISH", zmq.SNDMORE)
+        self.node2.send(self.transmit2)
+        req = self.node2.recv_multipart()
+        self.assertEqual(self.transmit1, req[1])
+
+# end ZBeaconTest
+
+if __name__ == '__main__':
+
+    #print(logging.Logger.manager.loggerDict)
+    logger = logging.getLogger()
+    logger.setLevel(logging.DEBUG)
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.DEBUG)
+    logger.addHandler(ch)
+    logging.getLogger("pyre.zbeacon2").setLevel(logging.DEBUG)
+    
+    try:
+        unittest.main()
+    except Exception as a:
+        print(a)

pyre-gevent-0.3.0/tests/test_zhelper.py

@@ -0,0 +1,32 @@
+import unittest
+from pyre import zhelper
+from pyre import zbeacon
+import zmq
+import time
+
+class ZHelperTest(unittest.TestCase):
+    
+    def test_get_ifaddrs(self):
+        ifs = zhelper.get_ifaddrs()
+        self.assertIsInstance(ifs, list)
+        self.assertIsInstance(ifs[0], dict)
+    # end test_get_ifaddrs
+
+    def test_get_ifaddrs_loopback(self):
+        ifs = zhelper.get_ifaddrs()
+        addrs = []
+        for iface in ifs:
+            #print(iface)
+            for i,v in iface.items():
+                #print(i,v)
+                # 2 is for ipv4
+                if v.get(2):
+                    addrs.append(v[2]['addr'])
+        self.assertIn('127.0.0.1', addrs)
+    # end test_get_ifaddrs_loopback
+
+# end ZHelperTest
+
+if __name__ == '__main__':
+    unittest.main()
+

pyre-gevent-0.2.3.dev3/pyre_gevent/__init__.py

@@ -1,8 +0,0 @@
-import re
-
-__all__ = ['pyre', 'zbeacon', 'zhelper']
-__version__ = '0.2.3.dev3'
-__version_info__ = tuple(int(v) for v in re.sub('[a-zA-Z]', '', __version__).split('.'))
-
-from .pyre import Pyre
-from .pyre_event import PyreEvent