ryu/build/lib.linux-armv7l-2.7/ryu/tests/integrated/vrrp_common.py

   1 # Copyright (C) 2013 Nippon Telegraph and Telephone Corporation.
   2 # Copyright (C) 2013 Isaku Yamahata <yamahata at valinux co jp>
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at
   7 #
   8 #    http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
  13 # implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 from __future__ import print_function
  18
  19 import time
  20 import random
  21
  22 from ryu.base import app_manager
  23 from ryu.lib import hub
  24 from ryu.lib import mac as lib_mac
  25 from ryu.lib.packet import vrrp
  26 from ryu.services.protocols.vrrp import api as vrrp_api
  27 from ryu.services.protocols.vrrp import event as vrrp_event
  28
  29
  30 _VRID = 7
  31 _PRIMARY_IP_ADDRESS0 = '10.0.0.2'
  32 _PRIMARY_IP_ADDRESS1 = '10.0.0.3'
  33
  34
  35 class VRRPCommon(app_manager.RyuApp):
  36     _IFNAME0 = None
  37     _IFNAME1 = None
  38
  39     def __init__(self, *args, **kwargs):
  40         super(VRRPCommon, self).__init__(*args, **kwargs)
  41
  42     def _main(self):
  43         self._main_version(vrrp.VRRP_VERSION_V3)
  44         self._main_version(vrrp.VRRP_VERSION_V2)
  45         print("done!")
  46
  47     def _main_version(self, vrrp_version):
  48         self._main_version_priority(vrrp_version,
  49                                     vrrp.VRRP_PRIORITY_ADDRESS_OWNER)
  50         self._main_version_priority(vrrp_version,
  51                                     vrrp.VRRP_PRIORITY_BACKUP_MAX)
  52         self._main_version_priority(vrrp_version,
  53                                     vrrp.VRRP_PRIORITY_BACKUP_DEFAULT)
  54         self._main_version_priority(vrrp_version,
  55                                     vrrp.VRRP_PRIORITY_BACKUP_MIN)
  56
  57     def _main_version_priority(self, vrrp_version, priority):
  58         self._main_version_priority_sleep(vrrp_version, priority, False)
  59         self._main_version_priority_sleep(vrrp_version, priority, True)
  60
  61     def _check(self, vrrp_api, instances):
  62         while True:
  63             while True:
  64                 rep = vrrp_api.vrrp_list(self)
  65                 if len(rep.instance_list) >= len(instances) * 2:
  66                     if any(i.state == vrrp_event.VRRP_STATE_INITIALIZE
  67                            for i in rep.instance_list):
  68                         continue
  69                     break
  70                 print('%s / %s' % (len(rep.instance_list), len(instances) * 2))
  71                 time.sleep(1)
  72
  73 #                for i in rep.instance_list:
  74 #                    print('%s %s %s %s %s' % (i.instance_name,
  75 #                          i.monitor_name,
  76 #                          i.config,
  77 #                          i.interface,
  78 #                          i.state))
  79             assert len(rep.instance_list) == len(instances) * 2
  80             num_of_master = 0
  81             d = dict(((i.instance_name, i) for i in rep.instance_list))
  82             bad = 0
  83             for i in rep.instance_list:
  84                 assert i.state in (vrrp_event.VRRP_STATE_MASTER,
  85                                    vrrp_event.VRRP_STATE_BACKUP)
  86                 if i.state == vrrp_event.VRRP_STATE_MASTER:
  87                     num_of_master += 1
  88
  89                 vr = instances[i.config.vrid]
  90                 if (vr[0].config.priority > vr[1].config.priority and
  91                         i.instance_name == vr[1].instance_name) or \
  92                    (vr[0].config.priority < vr[1].config.priority and
  93                         i.instance_name == vr[0].instance_name):
  94                     if i.state == vrrp_event.VRRP_STATE_MASTER:
  95                         print("bad master:")
  96                         print('%s %s' % (d[vr[0].instance_name].state,
  97                                          d[vr[0].instance_name].config.priority))
  98                         print('%s %s' % (d[vr[1].instance_name].state,
  99                                          d[vr[1].instance_name].config.priority))
 100                         bad += 1
 101 #                       assert i.state != vrrp_event.VRRP_STATE_MASTER
 102             if bad > 0:
 103                 # this could be a transient state
 104                 print("%s bad masters" % bad)
 105                 time.sleep(1)
 106                 continue
 107             if num_of_master >= len(instances):
 108                 assert num_of_master == len(instances)
 109                 break
 110             print('%s / %s' % (num_of_master, len(instances)))
 111             time.sleep(1)
 112             continue
 113
 114     def _main_version_priority_sleep(self, vrrp_version, priority, do_sleep):
 115         app_mgr = app_manager.AppManager.get_instance()
 116         self.logger.debug('%s', app_mgr.applications)
 117         vrrp_mgr = app_mgr.applications['VRRPManager']
 118
 119         step = 5
 120         instances = {}
 121         for vrid in range(1, 256, step):
 122             if vrid == _VRID:
 123                 continue
 124             print("vrid %s" % vrid)
 125             l = {}
 126             prio = max(vrrp.VRRP_PRIORITY_BACKUP_MIN,
 127                        min(vrrp.VRRP_PRIORITY_BACKUP_MAX, vrid))
 128             rep0 = self._configure_vrrp_router(vrrp_version,
 129                                                prio,
 130                                                _PRIMARY_IP_ADDRESS0,
 131                                                self._IFNAME0,
 132                                                vrid)
 133             assert rep0.instance_name is not None
 134             l[0] = rep0
 135             prio = max(vrrp.VRRP_PRIORITY_BACKUP_MIN,
 136                        min(vrrp.VRRP_PRIORITY_BACKUP_MAX, 256 - vrid))
 137             rep1 = self._configure_vrrp_router(vrrp_version,
 138                                                prio,
 139                                                _PRIMARY_IP_ADDRESS1,
 140                                                self._IFNAME1,
 141                                                vrid)
 142             assert rep1.instance_name is not None
 143             l[1] = rep1
 144             instances[vrid] = l
 145
 146         print("vrid %s" % _VRID)
 147         l = {}
 148         rep0 = self._configure_vrrp_router(vrrp_version, priority,
 149                                            _PRIMARY_IP_ADDRESS0,
 150                                            self._IFNAME0, _VRID)
 151         assert rep0.instance_name is not None
 152         l[0] = rep0
 153         rep1 = self._configure_vrrp_router(
 154             vrrp_version, vrrp.VRRP_PRIORITY_BACKUP_DEFAULT,
 155             _PRIMARY_IP_ADDRESS1, self._IFNAME1, _VRID)
 156         assert rep1.instance_name is not None
 157         l[1] = rep1
 158         instances[_VRID] = l
 159
 160         self.logger.debug('%s', vrrp_mgr._instances)
 161
 162         if do_sleep:
 163             print("priority %s" % priority)
 164             print("waiting for instances starting")
 165
 166             self._check(vrrp_api, instances)
 167
 168         for vrid in instances.keys():
 169             if vrid == _VRID:
 170                 continue
 171             which = vrid & 1
 172             new_priority = int(random.uniform(vrrp.VRRP_PRIORITY_BACKUP_MIN,
 173                                               vrrp.VRRP_PRIORITY_BACKUP_MAX))
 174             i = instances[vrid][which]
 175             vrrp_api.vrrp_config_change(self, i.instance_name,
 176                                         priority=new_priority)
 177             i.config.priority = new_priority
 178
 179         if do_sleep:
 180             print("priority shuffled")
 181
 182             self._check(vrrp_api, instances)
 183
 184         for vrid in instances.keys():
 185             if vrid == _VRID:
 186                 continue
 187             which = vrid & 1
 188             vrrp_api.vrrp_shutdown(self, instances[vrid][which].instance_name)
 189         vrrp_api.vrrp_shutdown(self, instances[_VRID][0].instance_name)
 190
 191         if do_sleep:
 192             print("shutting down instances")
 193             while True:
 194                 rep = vrrp_api.vrrp_list(self)
 195                 if len(rep.instance_list) <= len(instances):
 196                     break
 197                 print("left %s" % len(rep.instance_list))
 198                 time.sleep(1)
 199             assert len(rep.instance_list) == len(instances)
 200             print("waiting for the rest becoming master")
 201             while True:
 202                 rep = vrrp_api.vrrp_list(self)
 203                 if all(i.state == vrrp_event.VRRP_STATE_MASTER
 204                        for i in rep.instance_list):
 205                     break
 206                 time.sleep(1)
 207
 208         vrrp_api.vrrp_shutdown(self, instances[_VRID][1].instance_name)
 209         for vrid in instances.keys():
 210             if vrid == _VRID:
 211                 continue
 212             which = 1 - (vrid & 1)
 213             vrrp_api.vrrp_shutdown(self, instances[vrid][which].instance_name)
 214
 215         print("waiting for instances shutting down")
 216         while True:
 217             rep = vrrp_api.vrrp_list(self)
 218             if not rep.instance_list:
 219                 break
 220             print("left %s" % len(rep.instance_list))
 221             time.sleep(1)