They are exported events and classes. Signed-off-by: Isaku Yamahata <yamah...@valinux.co.jp> --- Changes v1 -> v2: - Linux network device support - dynamic configuration change --- ryu/services/vrrp/event.py | 266 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 266 insertions(+) create mode 100644 ryu/services/vrrp/event.py
diff --git a/ryu/services/vrrp/event.py b/ryu/services/vrrp/event.py new file mode 100644 index 0000000..a1ddd11 --- /dev/null +++ b/ryu/services/vrrp/event.py @@ -0,0 +1,266 @@ +# Copyright (C) 2013 Nippon Telegraph and Telephone Corporation. +# Copyright (C) 2013 Isaku Yamahata <yamahata at private email ne jp> +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +# implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Events for VRRP +""" + +import netaddr + +from ryu.controller import event +from ryu.lib import dpid as dpid_lib +from ryu.lib import mac as mac_lib +from ryu.lib.packet import vrrp + + +# When an instance is created, state transition is None -> Initialize +VRRP_STATE_INITIALIZE = 'Initialize' +VRRP_STATE_MASTER = 'Master' +VRRP_STATE_BACKUP = 'Backup' + + +VRRP_MANAGER_NAME = 'VRRPManager' + + +class VRRPInterfaceBase(object): + """ + interface on which VRRP router works + vlan_id = None means no vlan. + NOTE: multiple virtual router can be configured on single port + See RFC 5798 4.2 Sample Configuration 2 + """ + def __init__(self, mac_address, primary_ip_address, vlan_id=None): + super(VRRPInterfaceBase, self).__init__() + self.mac_address = mac_address + self.primary_ip_address = primary_ip_address + self.vlan_id = vlan_id + + def __eq__(self, other): + return (self.__class__ == other.__class__ and + self.mac_address == other.mac_address and + self.primary_ip_address == other.primary_ip_address and + self.vlan_id == other.vlan_id) + + def __hash__(self): + return hash((self.mac_address, self.primary_ip_address, self.vlan_id)) + + +class VRRPInterfaceNetworkDevice(VRRPInterfaceBase): + def __init__(self, mac_address, primary_ip_address, vlan_id, + device_name): + super(VRRPInterfaceNetworkDevice, self).__init__( + mac_address, primary_ip_address, vlan_id) + self.device_name = device_name + + def __str__(self): + return '%s<%s, %s, %s, %s>' % ( + self.__class__.__name__, + str(mac_lib.haddr_to_str(self.mac_address)), + str(netaddr.IPAddress(self.primary_ip_address)), self.vlan_id, + self.device_name) + + def __eq__(self, other): + return (super(VRRPInterfaceNetworkDevice, self).__eq__(other) and + self.device_name == other.device_name) + + def __hash__(self): + return hash((self.mac_address, self.primary_ip_address, self.vlan_id, + self.device_name)) + + +class VRRPInterfaceOpenFlow(VRRPInterfaceBase): + def __init__(self, mac_address, primary_ip_address, vlan_id, + dpid, port_no): + super(VRRPInterfaceOpenFlow, self).__init__( + mac_address, primary_ip_address, vlan_id) + self.dpid = dpid + self.port_no = port_no + + def __str__(self): + return '%s<%s, %s, %s, %s, %d>' % ( + self.__class__.__name__, + str(mac_lib.haddr_to_str(self.mac_address)), + str(netaddr.IPAddress(self.primary_ip_address)), self.vlan_id, + dpid_lib.dpid_to_str(self.dpid), self.port_no) + + def __eq__(self, other): + return (super(VRRPInterfaceOpenFlow, self).__eq__(other) and + self.dpid == other.dpid and self.port_no == other.port_no) + + def __hash__(self): + return hash((self.mac_address, self.primary_ip_address, self.vlan_id, + self.dpid, self.port_no)) + + +class VRRPConfig(object): + """ + advertmisement_interval is in seconds as float. (Not in centiseconds) + """ + def __init__(self, version=vrrp.VRRP_VERSION_V3, vrid=None, + priority=vrrp.VRRP_PRIORITY_BACKUP_DEFAULT, ip_addresses=None, + advertisement_interval=vrrp.VRRP_MAX_ADVER_INT_DEFAULT_IN_SEC, + preempt_mode=True, accept_mode=False): + # To allow version and priority default + assert vrid is not None + assert ip_addresses is not None + super(VRRPConfig, self).__init__() + + self.version = version + self.vrid = vrid + self.priority = priority + self.ip_addresses = ip_addresses + self.advertisement_interval = advertisement_interval + self.preempt_mode = preempt_mode + self.accept_mode = accept_mode + + self.is_ipv6 = vrrp.is_ipv6(ip_addresses[0]) + + @property + def address_owner(self): + return self.priority == vrrp.VRRP_PRIORITY_ADDRESS_OWNER + + def __eq__(self, other): + return (self.version == other.version and + self.vrid == other.vrid and + self.priority == other.priority and + self.ip_addresses == other.ip_addresses and + self.advertisement_interval == other.advertisement_interval and + self.preempt_mode == other.preempt_mode and + self.accept_mode == other.accept_mode and + self.is_ipv6 == other.is_ipv6) + + def __hash__(self): + hash((self.version, self.vrid, self.priority, self.ip_addresses, + self.advertisement_interval, self.preempt_mode, self.accept_mode, + self.is_ipv6)) + + +class EventVRRPConfigRequest(event.EventRequestBase): + """ + Request from management layer to VRRP manager to initialize VRRP Router. + """ + def __init__(self, interface, config): + super(EventVRRPConfigRequest, self).__init__() + self.dst = VRRP_MANAGER_NAME + self.interface = interface + self.config = config + + +class EventVRRPConfigReply(event.EventReplyBase): + def __init__(self, instance_name, interface, config): + # dst = None. dst is filled by app_base.RyuApp.send_reply() + super(EventVRRPConfigReply, self).__init__(None) + self.instance_name = instance_name # None means failure + self.interface = interface + self.config = config + + +class EventVRRPShutdownRequest(event.EventRequestBase): + """ + Request from management layer to VRRP to shutdown VRRP Router. + """ + def __init__(self, instance_name): + super(EventVRRPShutdownRequest, self).__init__() + self.instance_name = instance_name + + +class EventVRRPStateChanged(event.EventBase): + """ + Event that this VRRP Router changed its state. + """ + def __init__(self, instance_name, + interface, vrid, is_ipv6, old_state, new_state): + super(EventVRRPStateChanged, self).__init__() + self.instance_name = instance_name + self.interface = interface + self.vrid = vrid + self.is_ipv6 = is_ipv6 + self.old_state = old_state + self.new_state = new_state + + +class VRRPInstance(object): + def __init__(self, instance_name, monitor_name, config, interface): + super(VRRPInstance, self).__init__() + self.instance_name = instance_name + self.monitor_name = monitor_name + self.config = config + self.interface = interface + + +class EventVRRPListRequest(event.EventRequestBase): + """ + Event that requests list of configured VRRP router + instance_name=None means all instances. + """ + def __init__(self, instance_name=None): + super(EventVRRPListRequest, self).__init__() + self.instance_name = instance_name + + +class EventVRRPListReply(event.EventReplyBase): + def __init__(self, instance_list): + super(EventVRRPListReply, self).__init__() + self.instance_list = instance_list + + +class EventVRRPConfigChangeRequest(event.EventRequestBase): + """ + Event that requests to change configuration of a given VRRP router. + None means no-change. + """ + def __init__(self, instance_name, priority=None, + advertisement_interval=None, preempt_mode=None, + accept_mode=None): + super(EventVRRPConfigChangeRequest, self).__init__() + self.instance_name = instance_name + self.priority = priority + self.advertisement_interval = advertisement_interval + self.preempt_mode = preempt_mode + self.accept_mode = accept_mode + + +class EventVRRPRegisterRequest(event.EventRequestBase): + """ + Event that requiest to register an app to VRRP router + """ + def __init__(self, register, instance_name, observer_name): + super(EventVRRPRegisterRequest, self).__init__() + self.register = register # register or unregister + self.instance_name = instance_name + self.observer_name = observer_name + + +# Following classes are internally used by VRRP + +class EventVRRPReceived(event.EventBase): + """ + Event that port manager received valid VRRP packet. + Usually handed by VRRP Router. + """ + def __init__(self, interface, packet): + super(EventVRRPReceived, self).__init__() + self.interface = interface + self.packet = packet + + +class EventVRRPTransmitRequest(event.EventRequestBase): + """ + Request from VRRP router to port manager to transmit VRRP packet. + """ + def __init__(self, data): + super(EventVRRPTransmitRequest, self).__init__() + self.data = data -- 1.7.10.4 ------------------------------------------------------------------------------ Precog is a next-generation analytics platform capable of advanced analytics on semi-structured data. The platform includes APIs for building apps and a phenomenal toolset for data science. Developers can use our toolset for easy data analysis & visualization. Get a free account! http://www2.precog.com/precogplatform/slashdotnewsletter _______________________________________________ Ryu-devel mailing list Ryu-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/ryu-devel
