voltha/core/xpon_agent.py

# Copyright 2017 the original author or authors.
#
# 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.
#

import structlog
import sys
import functools

from voltha.registry import registry
from voltha.core.config.config_proxy import CallbackType
from voltha.protos.bbf_fiber_base_pb2 import ChannelgroupConfig, \
    ChannelpartitionConfig, ChannelpairConfig, ChannelterminationConfig, \
    OntaniConfig, VOntaniConfig, VEnetConfig, \
    AllTrafficDescriptorProfileData, AllTcontsConfigData, AllGemportsConfigData
from voltha.protos.bbf_fiber_traffic_descriptor_profile_body_pb2 import \
    TrafficDescriptorProfileData
from voltha.protos.bbf_fiber_tcont_body_pb2 import TcontsConfigData
from voltha.protos.bbf_fiber_gemport_body_pb2 import GemportsConfigData

from voltha.protos.device_pb2 import Device
from voltha.protos.common_pb2 import AdminState

log = structlog.get_logger()

class XponAgent(object):

    interface_stack = {
        ChannelgroupConfig: {
            'path': '/channel_groups/{}', 'path_keys': ['name'],
            'parent': None, 'parent_path': None, 'parent_path_keys': [None],
            'child': {
                1: {'config': ChannelpartitionConfig,
                    'child_path': ['/channel_partitions']}},
            'olt_link': None, 'olt_link_path': None,
                'olt_link_path_keys': [None], 'olt_device_id': 'from_child',
            'onu_link': None, 'onu_link_path': None,
                'onu_link_path_keys': [None], 'onu_device_id': 'na'},
        ChannelpartitionConfig: {
            'path': '/channel_partitions/{}', 'path_keys': ['name'],
            'parent': ChannelgroupConfig, 'parent_path': '/channel_groups/{}',
                'parent_path_keys': ['data.channelgroup_ref'],
            'child': {
                1: {'config': ChannelpairConfig,
                    'child_path': ['/channel_pairs']}},
            'olt_link': None, 'olt_link_path': None,
                'olt_link_path_keys': [None], 'olt_device_id': 'from_child',
            'onu_link': None, 'onu_link_path': None,
                'onu_link_path_keys': [None], 'onu_device_id': 'na'},
        ChannelpairConfig: {
            'path': '/channel_pairs/{}', 'path_keys': ['name'],
            'parent': ChannelpartitionConfig,
                'parent_path': '/channel_partitions/{}',
                'parent_path_keys': ['data.channelpartition_ref'],
            'child': {
                1: {'config': ChannelterminationConfig,
                    'child_path': ['/devices', 'channel_terminations']}},
            'olt_link': None, 'olt_link_path': None,
                'olt_link_path_keys': [None], 'olt_device_id': 'from_child',
            'onu_link': None, 'onu_link_path': None,
                'onu_link_path_keys': [None], 'onu_device_id': 'na'},
        ChannelterminationConfig: {
            'path': '/devices/{}/channel_terminations/{}',
                'path_keys': ['id', 'name'],
            'parent': ChannelpairConfig, 'parent_path': '/channel_pairs/{}',
                'parent_path_keys': ['data.channelpair_ref'],
            'child': None, 'child_path': [None],
            'olt_link': None, 'olt_link_path': None,
                'olt_link_path_keys': [None], 'olt_device_id': 'self',
            'onu_link': None, 'onu_link_path': None,
                'onu_link_path_keys': [None], 'onu_device_id': 'na'},
        VOntaniConfig: {
            'path': '/v_ont_anis/{}', 'path_keys': ['name'],
            'parent': ChannelpartitionConfig,
                'parent_path': '/channel_partitions/{}',
                'parent_path_keys': ['data.parent_ref'],
            'child': {
                1: {'config': VEnetConfig, 'child_path': ['/v_enets']},
                2: {'config': TcontsConfigData, 'child_path': ['/tconts']}},
            'olt_link': ChannelpairConfig,
                'olt_link_path': '/channel_pairs/{}',
                'olt_link_path_keys': ['data.preferred_chanpair'],
                'olt_device_id': 'from_link',
            'onu_link': None, 'onu_link_path': None,
                'onu_link_path_keys': [None], 'onu_device_id': 'self'},
        OntaniConfig: {
            'path': '/ont_anis/{}', 'path_keys': ['name'],
            'parent': None, 'parent_path': None, 'parent_path_keys': [None],
            'child': None, 'child_path': [None],
            'olt_link': VOntaniConfig, 'olt_link_path': '/v_ont_anis/{}',
                'olt_link_path_keys': ['name'], 'olt_device_id' : 'from_link',
            'onu_link': VOntaniConfig, 'onu_link_path': '/v_ont_anis/{}',
                'onu_link_path_keys': ['name'], 'onu_device_id': 'from_link'},
        VEnetConfig: {
            'path': '/v_enets/{}', 'path_keys': ['name'],
            'parent': VOntaniConfig, 'parent_path': '/v_ont_anis/{}',
                'parent_path_keys': ['data.v_ontani_ref'],
            'child': {
                1: {'config': GemportsConfigData,
                    'child_path': ['/gemports']}},
            'olt_link': None, 'olt_link_path': None,
                'olt_link_path_keys': [None], 'olt_device_id': 'from_parent',
            'onu_link': None, 'onu_link_path': None,
                'onu_link_path_keys': [None], 'onu_device_id': 'from_parent'},
        TcontsConfigData: {
            'path': '/tconts/{}', 'path_keys': ['name'],
            'parent': VOntaniConfig, 'parent_path': '/v_ont_anis/{}',
                'parent_path_keys': ['interface_reference'],
            'child': None, 'child_path': [None],
            'olt_link': None, 'olt_link_path': None,
                'olt_link_path_keys': [None], 'olt_device_id': 'from_parent',
            'onu_link': None, 'onu_link_path': None,
                'onu_link_path_keys': [None], 'onu_device_id': 'from_parent'},
        GemportsConfigData: {
            'path': '/gemports/{}', 'path_keys': ['name'],
            'parent': VEnetConfig, 'parent_path': '/v_enets/{}',
                'parent_path_keys': ['itf_ref'],
            'child': None, 'child_path': [None],
            'olt_link': None, 'olt_link_path': None,
                'olt_link_path_keys': [None], 'olt_device_id': 'from_parent',
            'onu_link': None, 'onu_link_path': None,
                'onu_link_path_keys': [None], 'onu_device_id': 'from_parent'}
                       }

    def __init__(self, core):
        self.core = core
        self.preData = None
        self.inReplay = False
        return

    def get_device_adapter_agent(self, device):
        assert device.adapter != ''
        adapter_agent = registry('adapter_loader').get_agent(device.adapter)
        log.debug('get-device-adapter-agent', device=device,
                  adapter_agent=adapter_agent)
        return adapter_agent

    def get_interface_path(self, data):
        interface = self.interface_stack[type(data)]
        id_val = {}
        count = 0
        for key in interface['path_keys']:
            id_val[count] = getattr(data, key)
            count+=1
        path = interface['path'].format(*id_val.values())
        return path

    def _child_predicate(self, data, child):
        return self.get_parent_data(child).name == data.name

    def _get_child_data_by_path (self, data, path):
        children = self.core.get_proxy('/').get(path)
        return next((child for child in children
                     if self._child_predicate(data, child)), None)

    def get_device(self, data, device_type):
        if data is None:
            return None
        interface_node = self.interface_stack[type(data)]
        device = None
        if interface_node['{}_device_id'.format(device_type)] == 'self':
            if device_type == 'olt':
                device = self.core.get_proxy('/').get('/devices/{}'.
                                                      format(data.id))
                return device
            elif device_type == 'onu':
                devs = self.core.get_proxy('/').get('/devices')
                for dev in devs:
                    if dev.serial_number == data.data.expected_serial_number:
                        return dev
        if device is None:
            if interface_node['{}_device_id'.
                              format(device_type)] == 'from_parent':
                device = self.get_device(self.get_parent_data(data),
                                         device_type)
            elif interface_node['{}_device_id'.
                                format(device_type)] == 'from_child':
                device = self.get_device(self.get_child_data(data),
                                         device_type)
            elif interface_node['{}_device_id'.
                                format(device_type)] == 'from_link':
                device = self.get_device(self.get_link_data(data, device_type),
                                         device_type)
        return device

    def get_parent_data(self, data):
        if data is None:
            return None
        interface_node = self.interface_stack[type(data)]
        if interface_node['parent'] is None:
            return None
        id_val = {}
        count = 0
        for key in interface_node['parent_path_keys']:
            id_val[count] = self.rgetattr(data, key)
            count+=1
        parent_path = interface_node['parent_path'].format(*id_val.values())
        try:
            parent_data = self.core.get_proxy('/').get(parent_path)
            if not parent_data:
                return None
            return parent_data
        except KeyError:
            log.info('xpon-agent-warning-interface-cannot-get-parent',
                     data=data)
            return None

    def get_child_data(self, data):
        interface_node = self.interface_stack[type(data)]
        child = None
        if len(interface_node['child'][1]['child_path']) > 1:
            top_children = self.core.get_proxy('/').get('{}'.format(
                interface_node['child'][1]['child_path'][0]))
            for top_child in top_children:
                child = self._get_child_data_by_path(data, '{}/{}/{}'.format(
                    interface_node['child'][1]['child_path'][0], top_child.id,
                    interface_node['child'][1]['child_path'][1]))
                if child is not None:
                    return child
        else:
            child = self._get_child_data_by_path(data, '{}'.format(
                interface_node['child'][1]['child_path'][0]))
        if child is None:
            log.info('xpon-agent-warning-interface-cannot-get-child',
                     data=data)
        return child

    def get_link_data(self, data, device_type):
        interface_node = self.interface_stack[type(data)]
        if interface_node['{}_link'.format(device_type)] is None:
            return None
        id_val = {}
        count = 0
        for key in interface_node['{}_link_path_keys'.format(device_type)]:
            id_val[count] = self.rgetattr(data, key)
            count+=1
        link_path = interface_node['{}_link_path'.format(device_type)].format(
            *id_val.values())
        try:
            link_data = self.core.get_proxy('/').get(link_path)
            return link_data
        except KeyError:
            log.info('xpon-agent-warning-interface-cannot-get-{}-link-data'.
                     format(device_type), data=data)
            return None

    def rgetattr(self, obj, attr):
        def _getattr(obj, name):
            return getattr(obj, name)
        return functools.reduce(_getattr, [obj]+attr.split('.'))

    def is_valid_interface(self, data):
        valid = False
        for key in self.interface_stack.keys():
            valid |= isinstance(data, key)
        return valid

    def register_interface(self, device_id, path, update=True):
        log.info('register-interface:', device_id=device_id, path=path)
        try:
            interface_proxy = self.core.get_proxy(path)
            if update:
                interface_proxy.register_callback(CallbackType.POST_UPDATE,
                                                  self.update_interface,
                                                  device_id)
            else:
                interface_proxy.register_callback(CallbackType.POST_ADD,
                                                  self.create_interface,
                                                  device_id)
                interface_proxy.register_callback(CallbackType.POST_REMOVE,
                                                  self.remove_interface,
                                                  device_id)
        except:
            print "Unexpected error:", sys.exc_info()[0]

    def unregister_interface(self, device_id, path, update=True):
        log.info('unregister-interface:', device_id=device_id, path=path)
        try:
            interface_proxy = self.core.get_proxy(path)
            if update:
                interface_proxy.unregister_callback(CallbackType.POST_UPDATE,
                                                    self.update_interface,
                                                    device_id)
            else:
                interface_proxy.unregister_callback(CallbackType.POST_ADD,
                                                    self.create_interface,
                                                    device_id)
                interface_proxy.unregister_callback(CallbackType.POST_REMOVE,
                                                    self.remove_interface,
                                                    device_id)
        except:
            print "Unexpected error:", sys.exc_info()[0]

    def create_interface_in_device(self, device, data):
        if device is None:
            return
        log.info('xpon-agent-create-interface-in-device',
                 device_id=device.id, type=type(data).__name__, data=data)
        adapter_agent = self.get_device_adapter_agent(device)
        if (isinstance(data, TcontsConfigData)):
            # Adapter interfaces for TCONT always need traffic-descriptor
            traffic_descriptor_data = self.core.get_proxy('/').get(
                '/traffic_descriptor_profiles/{}'.
                format(data.traffic_descriptor_profile_ref))
            adapter_agent.create_tcont(
                device=device, tcont_data=data,
                traffic_descriptor_data=traffic_descriptor_data)
        elif (isinstance(data, TrafficDescriptorProfileData)):
            # Do nothing for now
            log.info(
                'create-interface-in-device-traffic-descriptor-do-nothing',
                device=device, data=data)
        elif (isinstance(data, GemportsConfigData)):
            adapter_agent.create_gemport(device=device, data=data)
        elif (isinstance(data, (ChannelgroupConfig, ChannelpartitionConfig,
                                ChannelpairConfig, ChannelterminationConfig,
                                OntaniConfig, VOntaniConfig, VEnetConfig))):
            adapter_agent.create_interface(device=device, data=data)
        else:
            # Not handled yet
            log.info('create-interface-in-device: Not handling',
                     device=device, data=data)

    def update_interface_in_device(self, device, data):
        if device is None:
            return
        log.info('xpon-agent-update-interface-in-device',
                 device_id=device.id, type=type(data).__name__, data=data)
        adapter_agent = self.get_device_adapter_agent(device)
        if (isinstance(data, TcontsConfigData)):
            # Adapter interfaces for TCONT always need traffic-descriptor
            traffic_descriptor_data = self.core.get_proxy('/').get(
                '/traffic_descriptor_profiles/{}'.
                format(data.traffic_descriptor_profile_ref))
            adapter_agent.update_tcont(
                device=device, tcont_data=data,
                traffic_descriptor_data=traffic_descriptor_data)
        elif (isinstance(data, TrafficDescriptorProfileData)):
            # Do nothing for now
            log.info(
                'update-interface-in-device-traffic-descriptor-do-nothing',
                device=device, data=data)
        elif (isinstance(data, GemportsConfigData)):
            adapter_agent.update_gemport(device=device, data=data)
        elif (isinstance(data, (ChannelgroupConfig, ChannelpartitionConfig,
                                ChannelpairConfig, ChannelterminationConfig,
                                OntaniConfig, VOntaniConfig, VEnetConfig))):
            adapter_agent.update_interface(device=device, data=data)
        else:
            # Not handled yet
            log.info('create-interface-in-device: Not handling',
                     device=device, data=data)

    def remove_interface_in_device(self, device, data):
        if device is None:
            return
        log.info('xpon-agent-remove-interface-in-device',
                 device_id=device.id, type=type(data).__name__, data=data)
        adapter_agent = self.get_device_adapter_agent(device)
        if (isinstance(data, TcontsConfigData)):
            # Adapter interfaces for TCONT always need traffic-descriptor
            traffic_descriptor_data = self.core.get_proxy('/').get(
                '/traffic_descriptor_profiles/{}'.
                format(data.traffic_descriptor_profile_ref))
            adapter_agent.remove_tcont(
                device=device, tcont_data=data,
                traffic_descriptor_data=traffic_descriptor_data)
        elif (isinstance(data, TrafficDescriptorProfileData)):
            # Do nothing for now
            log.info(
                'remove-interface-in-device-traffic-descriptor-do-nothing',
                device=device, data=data)
        elif (isinstance(data, GemportsConfigData)):
            adapter_agent.remove_gemport(device=device, data=data)
        elif (isinstance(data, (ChannelgroupConfig, ChannelpartitionConfig,
                                ChannelpairConfig, ChannelterminationConfig,
                                OntaniConfig, VOntaniConfig, VEnetConfig))):
            adapter_agent.remove_interface(device=device, data=data)
        else:
            # Not handled yet
            log.info('remove-interface-in-device: Not handling',
                     device=device, data=data)

    def create_interface(self, data, device_id=None):
        if not self.is_valid_interface(data):
            log.info('xpon-agent-create-interface-invalid-interface-type',
                     type=type(data).__name__)
            return
        if device_id is None:
            olt_device = self.get_device(data, 'olt')
        else:
            olt_device = self.core.get_proxy('/').get('/devices/{}'.
                                                      format(device_id))
        device_id = None if olt_device is None else olt_device.id
        self.register_interface(device_id=device_id,
                                path=self.get_interface_path(data))
        if olt_device is not None:
            if(isinstance(data, ChannelterminationConfig)):
                self.create_channel_termination(olt_device, data)
            elif(isinstance(data, VOntaniConfig)):
                self.create_onu_interfaces(data=data, olt_device=olt_device)
            else:
                log.info(
                    'xpon-agent-creating-interface-at-olt-device:',
                    olt_device_id=olt_device.id, data=data)
                self.create_interface_in_device(olt_device, data)
                interface_node = self.interface_stack[type(data)]
                if interface_node['onu_device_id'] != 'na':
                    onu_device = self.get_device(data, 'onu')
                    log.info(
                        'xpon-agent-creating-interface-at-onu-device:',
                        onu_device_id=onu_device.id, data=data)
                    self.create_interface_in_device(onu_device, data)

    def update_interface(self, data, device_id):
        if not self.is_valid_interface(data):
            log.info('xpon-agent-update-interface-invalid-interface-type',
                     type=type(data).__name__)
            return
        if device_id is None:
            olt_device = self.get_device(data, 'olt')
        else:
            olt_device = self.core.get_proxy('/').get('/devices/{}'.
                                                      format(device_id))
        if olt_device is not None:
            log.info('xpon-agent-updating-interface-at-olt-device',
                     olt_device_id=olt_device.id, data=data)
            self.update_interface_in_device(olt_device, data)
            interface_node = self.interface_stack[type(data)]
            if interface_node['onu_device_id'] != 'na':
                onu_device = self.get_device(data, 'onu')
                log.info('xpon-agent-updating-interface-at-onu-device:',
                         onu_device_id=onu_device.id, data=data)
                self.update_interface_in_device(onu_device, data)
                if isinstance(data, VOntaniConfig):
                    self.update_onu_device(olt_device, onu_device, data)

    def remove_interface(self, data, device_id=None):
        if not self.is_valid_interface(data):
            log.info('xpon-agent-remove-interface-invalid-interface-type',
                     type=type(data).__name__)
            return
        if device_id is None:
            olt_device = self.get_device(data, 'olt')
        else:
            olt_device = self.core.get_proxy('/').get('/devices/{}'.
                                                      format(device_id))
        if olt_device is not None:
            log.info('xpon-agent-remove-interface:',
                     olt_device_id=olt_device.id, data=data)
            if(isinstance(data, ChannelterminationConfig)):
                self.remove_channel_termination(olt_device, data)
            else:
                interface_node = self.interface_stack[type(data)]
                if interface_node['onu_device_id'] != 'na':
                    onu_device = self.get_device(data, 'onu')
                    log.info(
                        'xpon-agent-removing-interface-at-onu-device:',
                        onu_device_id=onu_device.id, data=data)
                    self.remove_interface_in_device(onu_device, data)
                log.info(
                    'xpon-agent-removing-interface-at-olt-device:',
                    olt_device_id=olt_device.id, data=data)
                self.remove_interface_in_device(olt_device, data)
                if isinstance(data, VOntaniConfig):
                    self.delete_onu_device(olt_device, onu_device)

    def create_channel_termination(self, olt_device, data):
        channel_pair = self.get_parent_data(data)
        channel_part = self.get_parent_data(channel_pair)
        channel_group = self.get_parent_data(channel_part)
        if channel_group is not None:
            log.info('xpon-agent-creating-channel-group',
                     olt_device_id=olt_device.id, channel_group=channel_group)
            self.create_interface_in_device(olt_device, channel_group)
        if channel_part is not None:
            log.info('xpon-agent-creating-channel-partition:',
                     olt_device_id=olt_device.id, channel_part=channel_part)
            self.create_interface_in_device(olt_device, channel_part)
        if channel_pair is not None:
            log.info('xpon-agent-creating-channel-pair:',
                     olt_device_id=olt_device.id, channel_pair=channel_pair)
            self.create_interface_in_device(olt_device, channel_pair)
        log.info('xpon-agent-creating-channel-termination:',
                 olt_device_id=olt_device.id, data=data)
        self.create_interface_in_device(olt_device, data)
        if channel_pair is None:
            return
        v_ont_anis = self.core.get_proxy('/').get('/v_ont_anis')
        for v_ont_ani in v_ont_anis:
            if self.get_link_data(v_ont_ani, 'olt').name == channel_pair.name:
                self.create_onu_interfaces(data=v_ont_ani, olt_device=olt_device)

    def create_onu_interfaces(self, data, olt_device=None, onu_device=None):
        if not self.inReplay:
            self.create_onu_device(device=olt_device, v_ont_ani=data)
            onu_device = self.get_device(data, 'onu')
        self.create_interface_in_device(olt_device, data)
        self.create_interface_in_device(onu_device, data)
        try:
            ont_ani = self.core.get_proxy('/').get('/ont_anis/{}'.
                                                   format(data.name))
            if ont_ani is not None:
                self.create_interface_in_device(olt_device, ont_ani)
                self.create_interface_in_device(onu_device, ont_ani)
            tconts = self.core.get_proxy('/').get('/tconts')
            for tcont in tconts:
                if self.get_parent_data(tcont).name == data.name:
                    self.create_interface_in_device(olt_device, tcont)
                    self.create_interface_in_device(onu_device, tcont)
            v_enets = self.core.get_proxy('/').get('/v_enets')
            for v_enet in v_enets:
                if self.get_parent_data(v_enet).name == data.name:
                    self.create_interface_in_device(olt_device, v_enet)
                    self.create_interface_in_device(onu_device, v_enet)
                    gemports = self.core.get_proxy('/').get('/gemports')
                    for gemport in gemports:
                        if self.get_parent_data(gemport).name == v_enet.name:
                            self.create_interface_in_device(olt_device,
                                                            gemport)
                            self.create_interface_in_device(onu_device,
                                                            gemport)
        except KeyError:
            log.info(
                'xpon-agent-create-onu-interfaces-no-ont-ani-link-exists')

    def remove_channel_termination(self, olt_device, data):
        channel_pair = self.get_parent_data(data)
        if channel_pair is None:
            log.info(
                'xpon-agent-removing-channel-termination:',
                olt_device_id=olt_device.id, data=data)
            self.remove_interface_in_device(olt_device, data)
            return
        self.remove_onu_interfaces(olt_device, channel_pair)
        log.info(
            'xpon-agent-removing-channel-termination:',
            olt_device_id=olt_device.id, data=data)
        self.remove_interface_in_device(olt_device, data)
        log.info(
            'xpon-agent-removing-channel-pair:',
            olt_device_id=olt_device.id, channel_pair=channel_pair)
        self.remove_interface_in_device(olt_device, channel_pair)
        channel_partition = self.get_parent_data(channel_pair)
        if channel_partition is not None:
            log.info(
                'xpon-agent-removing-channel-partition:',
                olt_device_id=olt_device.id,
                channel_partition=channel_partition)
            self.remove_interface_in_device(olt_device, channel_partition)
        channel_group = self.get_parent_data(channel_partition)
        if channel_group is not None:
            log.info(
                'xpon-agent-removing-channel-group:',
                olt_device_id=olt_device.id, channel_group=channel_group)
            self.remove_interface_in_device(olt_device, channel_group)

    def remove_onu_interfaces(self, olt_device, data):
        v_ont_anis = self.core.get_proxy('/').get('/v_ont_anis')
        for v_ont_ani in v_ont_anis:
            if self.get_link_data(v_ont_ani, 'olt').name == data.name:
                onu_device = self.get_device(v_ont_ani, 'onu')
                v_enets = self.core.get_proxy('/').get('/v_enets')
                for v_enet in v_enets:
                    if self.get_parent_data(v_enet).name == v_ont_ani.name:
                        gemports = self.core.get_proxy('/').get('/gemports')
                        for gemport in gemports:
                            if self.get_parent_data(gemport).name == \
                                v_enet.name:
                                log.info(
                                    'xpon-agent-remove-gemport-at-onu-device:',
                                    onu_device_id=onu_device.id,
                                    gemport=gemport)
                                self.remove_interface_in_device(onu_device,
                                                                gemport)
                                log.info(
                                    'xpon-agent-remove-gemport-at-olt-device:',
                                    olt_device_id=olt_device.id,
                                    gemport=gemport)
                                self.remove_interface_in_device(olt_device,
                                                                gemport)
                        log.info(
                            'xpon-agent-removing-v-enet-at-onu-device:',
                            onu_device_id=onu_device.id, data=v_enet)
                        self.remove_interface_in_device(onu_device, v_enet)
                        log.info(
                            'xpon-agent-removing-v-enet-at-olt-device:',
                            olt_device_id=olt_device.id, data=v_enet)
                        self.remove_interface_in_device(olt_device, v_enet)
                tconts = self.core.get_proxy('/').get('/tconts')
                for tcont in tconts:
                    if self.get_parent_data(tcont).name == v_ont_ani.name:
                        log.info(
                            'xpon-agent-removing-tcont-at-onu-device:',
                            onu_device_id=onu_device.id, tcont=tcont)
                        self.remove_interface_in_device(onu_device, tcont)
                        log.info(
                            'xpon-agent-removing-tcont-at-olt-device:',
                            olt_device_id=olt_device.id, tcont=tcont)
                        self.remove_interface_in_device(olt_device, tcont)
                try:
                    ont_ani = self.core.get_proxy('/').get(
                        '/ont_anis/{}'.format(v_ont_ani.name))
                    log.info(
                        'xpon-agent-removing-ont-ani-at-onu-device:',
                        onu_device_id=onu_device.id, data=ont_ani)
                    self.remove_interface_in_device(onu_device, ont_ani)
                    log.info(
                        'xpon-agent-removing-ont-ani-at-olt-device:',
                        olt_device_id=olt_device.id, data=ont_ani)
                    self.remove_interface_in_device(olt_device, ont_ani)
                except KeyError:
                    log.info(
                    'xpon-agent-remove-channel-termination-ont-ani-not-found')
                log.info(
                    'xpon-agent-removing-v-ont-ani-at-onu-device:',
                    onu_device_id=onu_device.id, data=v_ont_ani)
                self.remove_interface_in_device(onu_device, v_ont_ani)
                log.info(
                    'xpon-agent-removing-v-ont-ani-at-olt-device:',
                    olt_device_id=olt_device.id, data=v_ont_ani)
                self.remove_interface_in_device(olt_device, v_ont_ani)
                self.delete_onu_device(olt_device, onu_device)

    def replay_interface(self, device_id):
        self.inReplay = True
        if not self.is_onu_device_id(device_id):
            ct_items = self.core.get_proxy('/').get(
                '/devices/{}/channel_terminations'.format(device_id))
            for ct in ct_items:
                self.create_interface(data=ct, device_id=device_id)
        else:
            onu_device = self.core.get_proxy('/').get('/devices/{}'.
                                                      format(device_id))
            v_ont_anis = self.core.get_proxy('/').get('/v_ont_anis')
            for v_ont_ani in v_ont_anis:
                if v_ont_ani.data.expected_serial_number == \
                        onu_device.serial_number:
                    #self._create_onu_interfaces(onu_device, v_ont_ani)
                    self.create_onu_interfaces(data=v_ont_ani, onu_device=onu_device)
                    break
        self.inReplay = False

    def is_onu_device_id(self, device_id):
        device = self.core.get_proxy('/').get('/devices/{}'.format(device_id))
        return True if device.type.endswith("_onu") else False

    def get_port_num(self, device_id, label):
        log.info('get-port-num:', label=label, device_id=device_id)
        ports = self.core.get_proxy('/').get('/devices/{}/ports'.
                                             format(device_id))
        log.info('get-port-num:', label=label, device_id=device_id,
                 ports=ports)
        for port in ports:
            if port.label == label:
                return port.port_no
        return 0

    def get_channel_group_for_vont_ani(self, v_ont_ani):
        _cp = self.core.get_proxy('/').get('/channel_partitions/{}'.format(
            v_ont_ani.data.parent_ref))
        assert _cp is not None
        _cg = self.core.get_proxy('/').get('/channel_groups/{}'.format(
            _cp.data.channelgroup_ref))
        assert _cg is not None
        return _cg.cg_index

    def create_onu_device(self, device, v_ont_ani):
        log.info('create-onu-device', device_id=device.id, v_ont_ani=v_ont_ani)
        adapter_agent = self.get_device_adapter_agent(device)
        parent_chnl_pair_id = self.get_port_num(
            device.id, v_ont_ani.data.preferred_chanpair)
        log.info('create-onu-device:', parent_chnl_pair_id=parent_chnl_pair_id)
        vendor_id = v_ont_ani.data.expected_serial_number[:4]
        proxy_address = Device.ProxyAddress(
            device_id=device.id,
            channel_group_id=self.get_channel_group_for_vont_ani(v_ont_ani),
            channel_id=parent_chnl_pair_id,
            channel_termination=v_ont_ani.data.preferred_chanpair,
            onu_id=v_ont_ani.data.onu_id, onu_session_id=v_ont_ani.data.onu_id)
        adapter_agent.add_onu_device(
            parent_device_id=device.id, parent_port_no=parent_chnl_pair_id,
            vendor_id=vendor_id, proxy_address=proxy_address,
            root=True, serial_number=v_ont_ani.data.expected_serial_number,
            admin_state=AdminState.ENABLED if v_ont_ani.interface.enabled
                                           else AdminState.PREPROVISIONED)
        return

    def update_onu_device(self, olt_device, onu_device, v_ont_ani):
        log.info('update-onu-device', olt_device_id=olt_device.id,
                 onu_device_id=onu_device.id, v_ont_ani=v_ont_ani)
        adapter_agent = self.get_device_adapter_agent(olt_device)
        new_admin_state = AdminState.ENABLED if v_ont_ani.interface.enabled \
            else AdminState.DISABLED
        if onu_device.admin_state != new_admin_state:
            log.info('update-onu-device-admin-state',
                     onu_device_id=onu_device.id,
                     new_admin_state=new_admin_state)
            onu_device.admin_state = new_admin_state
            self.core.get_proxy('/').update('/devices/{}'.format(onu_device.id),
                                            onu_device)

    def delete_onu_device(self, olt_device, onu_device):
        log.info('delete-onu-device', olt_device_id=olt_device.id,
                 onu_device_id=onu_device.id)
        adapter_agent = self.get_device_adapter_agent(olt_device)
        adapter_agent.delete_child_device(olt_device.id, onu_device.id)
        return