Merge "BUG-2383 : put empty routes structure to Loc-RIB"

diff --git a/pcep/pcepy/.gitignore b/pcep/pcepy/.gitignore
new file mode 100644 (file)
index 0000000..6a54531
--- /dev/null
+++ b/pcep/pcepy/.gitignore
@@ -0,0 +1,3 @@
+# Python
+.tox/
+*.egg-info/

diff --git a/pcep/pcepy/peer/__init__.py b/pcep/pcepy/peer/__init__.py
index 73a49f7dff089a38b7c383e795c98a853c24dff5..2e475fd9d7297a4af31a564df04c56494c4cd184 100644 (file)
--- a/pcep/pcepy/peer/__init__.py
+++ b/pcep/pcepy/peer/__init__.py
@@ -7,7 +7,6 @@
 # and is available at http://www.eclipse.org/legal/epl-v10.html
 
 
-from .context import Context
-from .pce import Pce
-from .pcc import Pcc
-
+from .context import Context  # noqa
+from .pce import Pce  # noqa
+from .pcc import Pcc  # noqa

diff --git a/pcep/pcepy/session/__init__.py b/pcep/pcepy/session/__init__.py
index b658b791efb1fa40413c616ea5e8f03ab39a909a..ca5d5ce4c8103636bb902a81ffc588278f4f66eb 100644 (file)
--- a/pcep/pcepy/session/__init__.py
+++ b/pcep/pcepy/session/__init__.py
@@ -7,6 +7,5 @@
 # terms of the Eclipse Public License v1.0 which accompanies this distribution,
 # and is available at http://www.eclipse.org/legal/epl-v10.html
 
-from ._session import *
-from .bus import Bus
-
+from ._session import *  # noqa
+from .bus import Bus  # noqa

diff --git a/pcep/pcepy/session/_session.py b/pcep/pcepy/session/_session.py
index f034d49e0d5e7d2343f10e72e1fcd503648b2715..09cb558fe8186ae961c90f744a28b48dba79673f 100644 (file)
--- a/pcep/pcepy/session/_session.py
+++ b/pcep/pcepy/session/_session.py
@@ -16,7 +16,7 @@ except ImportError:
 import time
 import weakref
 
-from .bus import resolve_timeout, min_timeout
+from .bus import resolve_timeout
 from pcepy import message as _message
 
 # Standard assigned port for PCEP
@@ -25,6 +25,7 @@ PCEP_PORT = 4189
 import logging
 _LOGGER = logging.getLogger('pcepy.session')
 
+
 class Node(object):
     """A representation for an IP address with optional port;
     giving it a role and a name. End point of a connection.
@@ -38,8 +39,8 @@ class Node(object):
     compatible type(s) before use.
     """
 
-    ROLE_PCE = 'role.pce' # The node is a PCE (server or open connection)
-    ROLE_PCC = 'role.pcc' # The node is a PCC (client or open connection)
+    ROLE_PCE = 'role.pce'  # The node is a PCE (server or open connection)
+    ROLE_PCC = 'role.pcc'  # The node is a PCC (client or open connection)
 
     PORT_SUP = 1 << 16
 
@@ -76,10 +77,9 @@ class Node(object):
 
     def __eq__(self, other):
         return (self.role == other.role
-            and self.name == other.name
-            and self.address == other.address
-            and self.port == other.port
-        )
+                and self.name == other.name
+                and self.address == other.address
+                and self.port == other.port)
 
     def __ne__(self, other):
         return not self.__eq__(other)
@@ -119,7 +119,7 @@ class Session(object):
     CONFIG_NAME = 'session.name'
     STATE_CLOSING = '_session.closing'
 
-    _socket = None # Subclasses must set socket for each instance
+    _socket = None  # Subclasses must set socket for each instance
 
     def __init__(self, peer, local, config):
         self._peer = weakref.ref(peer)
@@ -172,9 +172,8 @@ class Session(object):
 
     def _update_name(self):
         """Update name to reflect change in node port(s)"""
-        self._name = (self[Session.CONFIG_NAME]
-            or '%s[%s/%s]' % (self.__class__.__name__, self.peer, self._local)
-        )
+        self._name = (self[Session.CONFIG_NAME] or
+                      '%s[%s/%s]' % (self.__class__.__name__, self.peer, self._local))
 
     def is_server(self):
         """Return if this is a server socket session"""
@@ -289,9 +288,10 @@ class PcepServer(Session):
             )
         except (_socket.error, ValueError, IndexError) as error:
             self._error = error
-            if self.peer.emit('on_socket_error', session=self,
-                error=error, action='open',
-            ) is not CANCEL_EVENT:
+            if self.peer.emit('on_socket_error',
+                              session=self,
+                              error=error,
+                              action='open') is not CANCEL_EVENT:
                 self.closing = True
         super(PcepServer, self).open(bus)
 
@@ -300,13 +300,16 @@ class PcepServer(Session):
             accept_socket, address = self._socket.accept()
         except _socket.error as error:
             self._error = error
-            self.peer.emit('on_socket_error', session=self,
-                error=error, action='accept'
-            )
+            self.peer.emit('on_socket_error',
+                           session=self,
+                           error=error,
+                           action='accept')
             return
-        self.peer.emit('on_connection', server=self,
-            socket=accept_socket, address=address
-        )
+
+        self.peer.emit('on_connection',
+                       server=self,
+                       socket=accept_socket,
+                       address=address)
 
 
 class _PcepSession(Session):
@@ -382,13 +385,11 @@ class _PcepSession(Session):
     def send(self, message):
         """Called by peer to send the message"""
         if self.closing:
-            _LOGGER.warning('%s: Sending %s message <%s> to a closing session'
-                % (self, message.__class__.__name__, id(message))
-            )
+            _LOGGER.warning('%s: Sending %s message <%s> to a closing session' % (
+                            self, message.__class__.__name__, id(message)))
         else:
-            _LOGGER.info('%s: Sending %s message <%s>'
-                % (self, message.__class__.__name__, id(message))
-            )
+            _LOGGER.info('%s: Sending %s message <%s>' % (
+                         self, message.__class__.__name__, id(message)))
         self._outbox.put(message)
         self.bus.hail()
 
@@ -399,9 +400,7 @@ class _PcepSession(Session):
             )
         except _socket.error as error:
             self._error = error
-            self.peer.emit('on_socket_error', session=self,
-                error=error, action='read'
-            )
+            self.peer.emit('on_socket_error', session=self, error=error, action='read')
             self.closing = True
             return
 
@@ -413,15 +412,12 @@ class _PcepSession(Session):
             try:
                 message = self._outbox.get_nowait()
             except queue.Empty:
-                _LOGGER.error('Session %s wants write while nothing to write'
-                    % self
-                )
+                _LOGGER.error('Session %s wants write while nothing to write' % self)
                 return
 
-            if self.peer.emit('on_transmit', session=self,
-                message=message
-            ) is CANCEL_EVENT:
+            if self.peer.emit('on_transmit', session=self, message=message) is CANCEL_EVENT:
                 return
+
             transmission = _message.Transmission(session=self)
             self._last_sent = transmission.time
             message.transmission = transmission
@@ -432,12 +428,9 @@ class _PcepSession(Session):
             try:
                 written = message.write(self.__outgoing, 0)
             except Exception as error:
-                _LOGGER.exception('%s: Cannot serialize message <%s>: %s'
-                    % (self, id(message), error)
-                )
-                self.peer.emit('on_message_error', session=self,
-                    message=message, error=error, action='send'
-                )
+                _LOGGER.exception('%s: Cannot serialize message <%s>: %s' % (
+                                  self, id(message), error))
+                self.peer.emit('on_message_error', session=self, message=message, error=error, action='send')
                 del self.__outgoing[:]
                 self.__message = None
                 return
@@ -447,19 +440,15 @@ class _PcepSession(Session):
                     '%s: Message <%s> written size %s != reserved size %s'
                     % (self, id(message), written, size)
                 )
-            _LOGGER.debug('%s: Message <%s> written to <%s>[%s]: %s'
-                % (self, id(message), id(self.__outgoing), len(self.__outgoing),
-                    _message.data.to_hex(self.__outgoing)
-                )
-            )
+            _LOGGER.debug('%s: Message <%s> written to <%s>[%s]: %s' % (
+                          self, id(message), id(self.__outgoing), len(self.__outgoing),
+                          _message.data.to_hex(self.__outgoing)))
 
         try:
             written = self._socket.send(self.__outgoing)
         except _socket.error as error:
             self._error = error
-            self.peer.emit('on_socket_error', session=self,
-                error=error, action='send'
-            )
+            self.peer.emit('on_socket_error', session=self, error=error, action='send')
             self.closing = True
             return
         del self.__outgoing[:written]
@@ -470,32 +459,23 @@ class _PcepSession(Session):
             self.__message = None
 
     def want_close(self):
-        return (self._error
-            or (not self.want_write()
-                and super(_PcepSession, self).want_close()
-            )
-        )
+        return (self._error or (not self.want_write() and super(_PcepSession, self).want_close()))
 
     def want_write(self):
         return bool(self.__outgoing) or not self._outbox.empty()
 
     def close(self):
         if self.want_write():
-            _LOGGER.warning('%s: closing with %s bytes and %s messages to write'
-                % (self, len(self.__outgoing), self._outbox.qsize())
-            )
+            _LOGGER.warning('%s: closing with %s bytes and %s messages to write' % (
+                            self, len(self.__outgoing), self._outbox.qsize()))
         super(_PcepSession, self).close()
 
     def _read_header(self, header):
         """Read header and adjust want_read for the rest of message."""
         header.read(self.__incoming, 0, len(self.__incoming))
         length = header.length
-        if (header.version != _message.code.PCEP_VERSION
-            or not length or length % 4
-        ):
-            if self.peer.emit('on_bad_header', session=self,
-                header=header
-            ) is CANCEL_EVENT:
+        if (header.version != _message.code.PCEP_VERSION or not length or length % 4):
+            if self.peer.emit('on_bad_header', session=self, header=header) is CANCEL_EVENT:
                 del self.__incoming[:]
                 return
 
@@ -504,29 +484,21 @@ class _PcepSession(Session):
 
     def _read_message(self):
         """Read message (header)"""
-        _LOGGER.debug('%s: reading incoming data <%s>[%s]: %s'
-            % (self, id(self.__incoming), len(self.__incoming),
-                _message.data.to_hex(self.__incoming)
-            )
-        )
+        _LOGGER.debug('%s: reading incoming data <%s>[%s]: %s' % (
+                      self, id(self.__incoming), len(self.__incoming),
+                      _message.data.to_hex(self.__incoming)))
         header = self._header
         if self.__want_read == header.size:
             self._read_header(header)
 
         if self.__want_read > len(self.__incoming):
-            return # need more data
+            return  # need more data
 
         try:
-            message = _message.Message.get_message(
-                self.__incoming, header.type_id
-            )
+            message = _message.Message.get_message(self.__incoming, header.type_id)
         except Exception as error:
-            _LOGGER.exception('%s: Cannot parse message in <%s>: %s'
-                % (self, id(self.__incoming), error)
-            )
-            self.peer.emit('on_message_error', session=self,
-                message=message, error=error, action='read'
-            )
+            _LOGGER.exception('%s: Cannot parse message in <%s>: %s' % (self, id(self.__incoming), error))
+            self.peer.emit('on_message_error', session=self, message=message, error=error, action='read')
             return
         finally:
             del self.__incoming[:]
@@ -542,6 +514,7 @@ class _PcepSession(Session):
         super(_PcepSession, self)._update_name()
         self._name += '->[%s]' % self._remote
 
+
 class PcepAccept(_PcepSession):
     """A PCEP session accepted by a PcepServer."""
 
@@ -585,9 +558,7 @@ class PcepClient(_PcepSession):
             self._socket.bind(socket_address)
         except (_socket.error, ValueError, IndexError) as error:
             self._error = error
-            self.peer.emit('on_socket_error', session=self,
-                error=error, action='open',
-            )
+            self.peer.emit('on_socket_error', session=self, error=error, action='open')
             self.closing = True
             return
 
@@ -604,9 +575,7 @@ class PcepClient(_PcepSession):
                     raise error
         except (_socket.error, ValueError, IndexError) as error:
             self._error = error
-            self.peer.emit('on_socket_error', session=self,
-                error=error, action='connect',
-            )
+            self.peer.emit('on_socket_error', session=self, error=error, action='connect')
             self.closing = True
             return
 
@@ -623,9 +592,7 @@ class PcepClient(_PcepSession):
             if error:
                 error = _socket.error(error, os.strerror(error))
                 self._error = error
-                self.peer.emit('on_socket_error', session=self,
-                    error=error, action='connect'
-                )
+                self.peer.emit('on_socket_error', session=self, error=error, action='connect')
                 self.closing = True
                 return
             self._established = True
@@ -639,9 +606,7 @@ class PcepClient(_PcepSession):
         if not self._established:
             error = _socket.timeout('Connection to "%s" timed out' % self._remote)
             self._error = error
-            self.peer.emit('on_socket_error', session=self,
-                error=error, action='connect'
-            )
+            self.peer.emit('on_socket_error', session=self, error=error, action='connect')
             del self[PcepClient.STATE_CONNECTAT]
             self.closing = True
         else:
@@ -654,4 +619,3 @@ class PcepClient(_PcepSession):
         if self._established:
             return super(PcepClient, self).timeout()
         return self._config.get(PcepClient.STATE_CONNECTAT)
-

diff --git a/pcep/pcepy/session/bus.py b/pcep/pcepy/session/bus.py
index b31c18a1972a748b2138e67fd8a46748acd71887..256ae1a97226b119f1d734a5f054650f0dfd506e 100644 (file)
--- a/pcep/pcepy/session/bus.py
+++ b/pcep/pcepy/session/bus.py
@@ -14,6 +14,7 @@ import threading
 import logging
 _LOGGER = logging.getLogger('pcepy.session.bus')
 
+
 class Bus(threading.Thread):
     """Manage all PCEP connections (sockets) in a dedicated thread"""
 
@@ -83,7 +84,7 @@ class Bus(threading.Thread):
                         connection.close()
                         break
                 else:
-                    break # No change
+                    break  # No change
             if not self.working():
                 break
             if not retries:
@@ -127,10 +128,11 @@ class Bus(threading.Thread):
         """Called whenever there is something on the control pipe"""
         pass
 
+
 class CtlPipe(object):
     """Pipe-based control channel"""
 
-    #TIP: could also be used for per-PCE control with named pipes
+    # TIP: could also be used for per-PCE control with named pipes
 
     def __init__(self, owner):
         self.owner = owner
@@ -181,6 +183,7 @@ def resolve_timeout(timeout, now=None):
         return timeout
     return now + timeout
 
+
 def min_timeout(time1, time2):
     """Return the earliest timeout, if any."""
     if time1 is None:
@@ -191,4 +194,3 @@ def min_timeout(time1, time2):
         return time1
     else:
         return time2
-

diff --git a/pcep/pcepy/setup.py b/pcep/pcepy/setup.py
new file mode 100644 (file)
index 0000000..c51dad2
--- /dev/null
+++ b/pcep/pcepy/setup.py
@@ -0,0 +1,14 @@
+# PCE and its handlers
+
+# Copyright (c) 2012,2013,2015 Cisco Systems, Inc. and others.  All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v1.0 which accompanies this distribution,
+# and is available at http://www.eclipse.org/legal/epl-v10.html
+
+# Workaround for tox missing parameter 'skipsdist=true' which was not
+# introduced until tox 1.6.0
+
+import setuptools
+
+setuptools.setup(name='pcepy')

diff --git a/pcep/pcepy/tox.ini b/pcep/pcepy/tox.ini
new file mode 100644 (file)
index 0000000..f0af252
--- /dev/null
+++ b/pcep/pcepy/tox.ini
@@ -0,0 +1,20 @@
+# PCE and its handlers
+
+# Copyright (c) 2012,2013,2015 Cisco Systems, Inc. and others.  All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v1.0 which accompanies this distribution,
+# and is available at http://www.eclipse.org/legal/epl-v10.html
+
+[tox]
+envlist = pep8
+#skipsdist = true  # Command only available in tox 1.6.0
+
+[testenv:pep8]
+deps = flake8
+commands = flake8
+
+[flake8]
+max-line-length = 120
+
+