Introducing arista Vlan management

In addition, netman's communications to Arista switches uses the
pyeapi tool

Author: Stephane Robert

netman/adapters/switches/arista.py

@@ -0,0 +1,82 @@
+import pyeapi
+from pyeapi.api.vlans import Vlans, isvlan
+from pyeapi.client import Node
+from pyeapi.eapilib import CommandError
+
+from netman.core.objects.exceptions import VlanAlreadyExist, UnknownVlan, BadVlanNumber, BadVlanName, \
+    OperationNotCompleted
+from netman.core.objects.switch_base import SwitchBase
+from netman.core.objects.vlan import Vlan
+
+
+class Arista(SwitchBase):
+    def __init__(self, switch_descriptor):
+        super(Arista, self).__init__(switch_descriptor)
+        self.switch_descriptor = switch_descriptor
+
+    def _connect(self):
+        self.conn = pyeapi.connect(host=self.switch_descriptor.hostname,
+                                   username=self.switch_descriptor.username,
+                                   password=self.switch_descriptor.password,
+                                   port=self.switch_descriptor.port,
+                                   transport='http')
+
+        self.node = Node(self.conn, transport='http', host=self.switch_descriptor.hostname,
+                         username=self.switch_descriptor.username, password=self.switch_descriptor.password,
+                         port=self.switch_descriptor.port)
+
+    def _disconnect(self):
+        self.conn = None
+
+    def _end_transaction(self):
+        pass
+
+    def _start_transaction(self):
+        pass
+
+    def get_vlan(self, number):
+        try:
+            vlans_info = self.conn.execute("show vlan {}".format(number))
+        except CommandError:
+            raise UnknownVlan(number)
+
+        return self._extract_vlan_list(vlans_info)[0]
+
+    def get_vlans(self):
+        vlans_info = self.conn.execute("show vlan")
+
+        return self._extract_vlan_list(vlans_info)
+
+    def add_vlan(self, number, name=None):
+        if not isvlan(number):
+            raise BadVlanNumber()
+        try:
+            self.conn.execute("show vlan {}".format(number))
+            raise VlanAlreadyExist(number)
+        except CommandError:
+            pass
+
+        commands = ["name {}".format(name)] if name else []
+
+        vlan = Vlans(self.node)
+        if not vlan.configure_vlan(number, commands):
+            raise BadVlanName()
+
+    def remove_vlan(self, number):
+        try:
+            self.conn.execute("show vlan {}".format(number))
+        except CommandError:
+            raise UnknownVlan(number)
+
+        vlan = Vlans(self.node)
+        if not vlan.delete(number):
+            raise OperationNotCompleted("Unable to remove vlan {}".format(number))
+
+    def _extract_vlan_list(self, vlans_info):
+        vlan_list = []
+        for id, vlan in vlans_info['result'][0]['vlans'].items():
+            if vlan['name'] == ("VLAN{:04d}".format(int(id))):
+                vlan['name'] = None
+
+            vlan_list.append(Vlan(number=int(id), name=vlan['name'], icmp_redirects=True, arp_routing=True, ntp=True))
+        return vlan_list

requirements.txt

@@ -5,3 +5,4 @@ paramiko>=1.15.1,<1.18
 netaddr>=0.7.13
 ncclient>=0.5.0
 requests>=2.6.2
+pyeapi

test-requirements.txt

@@ -2,8 +2,9 @@ nose>=1.2.1
 mock>=1.0.1
 pyhamcrest>=1.6
 flexmock>=0.10.2
-fake-switches>=1.2.4
+fake-switches>=1.3.0
 MockSSH>=1.4.2,!=1.4.5 # 1.4.5 has fixed dependency and freezes paramiko
 gunicorn>=19.4.5
 flake8==3.4.1
 futures; # Runtime dependency of gunicorn
+jabstract

tests/adapters/switches/arista_test.py

@@ -0,0 +1,128 @@
+import unittest
+
+from flexmock import flexmock, flexmock_teardown
+from hamcrest import assert_that, has_length, equal_to, is_
+from pyeapi.api.vlans import Vlans
+from pyeapi.eapilib import CommandError
+
+from netman.adapters.switches.arista import Arista
+from netman.core.objects.exceptions import BadVlanNumber, VlanAlreadyExist, BadVlanName, UnknownVlan, \
+    OperationNotCompleted
+from netman.core.objects.switch_descriptor import SwitchDescriptor
+from tests.fixtures.arista import vlans_payload, vlan_data
+
+
+class AristaTest(unittest.TestCase):
+
+    def setUp(self):
+        self.switch = Arista(SwitchDescriptor(model='arista', hostname="my.hostname"))
+        self.switch.conn = flexmock()
+        self.switch.node = flexmock()
+
+    def tearDown(self):
+        flexmock_teardown()
+
+    def test_get_vlans(self):
+        four_vlans_payload = vlans_payload(result=[{'vlans': {'1': vlan_data(name='default'),
+                                                              '123': vlan_data(name='VLAN0123'),
+                                                              '456': vlan_data(name='Patate'),
+                                                              '4444': vlan_data(name='VLAN4444')}}])
+
+        self.switch.conn.should_receive("execute").with_args("show vlan").once().and_return(four_vlans_payload)
+
+        vlan_list = self.switch.get_vlans()
+        vlan_list = sorted(vlan_list, key=lambda x: x.number)
+
+        assert_that(vlan_list, has_length(4))
+        assert_that(vlan_list[0].number, equal_to(1))
+        assert_that(vlan_list[0].name, equal_to("default"))
+
+    def test_get_vlans_with_default_name_returns_no_name(self):
+        my_vlan = {u'status': u'active', u'interfaces': {}, u'dynamic': False, u'name': u'VLAN0123'}
+
+        self.switch.conn.should_receive("execute").with_args("show vlan").once() \
+                        .and_return(vlans_payload(result=[{'vlans': {'123': my_vlan}}]))
+
+        vlan_list = self.switch.get_vlans()
+        vlan_list = sorted(vlan_list, key=lambda x: x.number)
+
+        assert_that(vlan_list[0].number, equal_to(123))
+        assert_that(vlan_list[0].name, equal_to(None))
+
+    def test_get_vlan_doesnt_exist(self):
+        self.switch.conn.should_receive("execute").with_args("show vlan 111").and_raise(CommandError(1000, 'msg'))
+
+        with self.assertRaises(UnknownVlan):
+            self.switch.get_vlan(111)
+
+    def test_get_vlan(self):
+        self.switch.conn.should_receive("execute").with_args("show vlan 123").once() \
+                        .and_return(vlans_payload(result=[{'vlans': {'123': vlan_data(name='My-Vlan-Name')}}]))
+
+        vlan = self.switch.get_vlan(123)
+
+        assert_that(vlan.number, is_(123))
+        assert_that(vlan.name, is_('My-Vlan-Name'))
+
+    def test_add_vlan(self):
+        vlan = flexmock(spec=Vlans)
+
+        self.switch.conn.should_receive("execute").with_args("show vlan 123").once().and_raise(
+            CommandError(1000, 'msg'))
+        vlan.should_receive("configure_vlan").with_args(123, []).once().and_return(True)
+
+        self.switch.add_vlan(123)
+
+    def test_add_vlan_with_name(self):
+        vlan = flexmock(spec=Vlans)
+
+        self.switch.conn.should_receive("execute").with_args("show vlan 123").once().and_raise(
+            CommandError(1000, 'msg'))
+        vlan.should_receive("configure_vlan").with_args(123, ["name gertrude"]).once().and_return(True)
+
+        self.switch.add_vlan(123, "gertrude")
+
+    def test_add_vlan_bad_vlan_number(self):
+        with self.assertRaises(BadVlanNumber):
+            self.switch.add_vlan(12334)
+
+    def test_add_vlan_already_exits(self):
+        self.switch.conn.should_receive("execute").with_args("show vlan 123").once()\
+                        .and_return(vlans_payload(result=[{'vlans': {'123': vlan_data(name='VLAN0123')}}]))
+
+        with self.assertRaises(VlanAlreadyExist):
+            self.switch.add_vlan(123)
+
+    def test_add_vlan_bad_vlan_name(self):
+        vlan = flexmock(spec=Vlans)
+
+        self.switch.conn.should_receive("execute").with_args("show vlan 123").once().and_raise(
+            CommandError(1000, 'msg'))
+        vlan.should_receive("configure_vlan").with_args(123, ["name gertrude_invalid_name"]).once().and_return(False)
+
+        with self.assertRaises(BadVlanName):
+            self.switch.add_vlan(123, "gertrude_invalid_name")
+
+    def test_remove_vlan(self):
+        vlan = flexmock(spec=Vlans)
+
+        self.switch.conn.should_receive("execute").with_args("show vlan 123").once()
+        vlan.should_receive("delete").with_args(123).once().and_return(True)
+
+        self.switch.remove_vlan(123)
+
+    def test_remove_vlan_unknown_vlan(self):
+        self.switch.conn.should_receive("execute").with_args("show vlan 123").once().and_raise(
+            CommandError(1000, 'msg'))
+
+        with self.assertRaises(UnknownVlan):
+            self.switch.remove_vlan(123)
+
+    def test_remove_vlan_unable_to_remove(self):
+        vlan = flexmock(spec=Vlans)
+
+        self.switch.conn.should_receive("execute").with_args("show vlan 123").once()
+        vlan.should_receive("delete").with_args(123).once().and_return(False)
+
+        with self.assertRaises(OperationNotCompleted):
+            self.switch.remove_vlan(123)

tests/fixtures/__init__.py

@@ -0,0 +1,9 @@
+from jabstract import jabstract
+
+vlans_payload = jabstract(
+    {'jsonrpc': '2.0', 'id': '4418851472',
+     'result': [{'sourceDetail': '', 'vlans': {}}]
+     }
+)
+
+vlan_data = jabstract({'status': 'active', 'interfaces': {}, 'dynamic': False, 'name': 'Name'})