def __init__(self, omci_agent):
super(MibDbLazyWriteDict, self).__init__(omci_agent)
self.args = registry('main').get_args()
host, port = self.args.etcd.split(':', 1)
self._kv_store = TwistedEtcdStore(host, port,
MibDbLazyWriteDict.MIB_PATH)
self._lazymetadata = dict()
def add_uni_ports(self):
""" Called after in-sync achieved and not in xPON mode"""
# TODO: We have to methods adding UNI ports. Go to one
# TODO: Should this be moved to the omci.py module for this ONU?
# This is only for working WITHOUT xPON
pptp_entities = self.openomci.onu_omci_device.configuration.pptp_entities
device = self.adapter_agent.get_device(self.device_id)
multi_uni = len(pptp_entities) > 1
uni_id = 0
for entity_id, pptp in pptp_entities.items():
intf_id = self.proxy_address.channel_id
onu_id = self.proxy_address.onu_id
uni_no = platform.mk_uni_port_num(intf_id, onu_id, uni_id=uni_id)
uni_name = "uni-{}".format(uni_no)
mac_bridge_port_num = uni_id + 1
uni_port = UniPort.create(self, uni_name, uni_no, uni_name)
uni_port.entity_id = entity_id
uni_port.enabled = True
uni_port.mac_bridge_port_num = mac_bridge_port_num
uni_port.add_logical_port(uni_port.port_number, multi_uni)
self.log.debug("created-uni-port", uni=uni_port)
self.adapter_agent.add_port(device.id, uni_port.get_port())
parent_device = self.adapter_agent.get_device(device.parent_id)
parent_adapter_agent = registry('adapter_loader').get_agent(
parent_device.adapter)
if parent_adapter_agent is None:
self.log.error('olt-adapter-agent-could-not-be-retrieved')
parent_adapter_agent.add_port(device.parent_id,
uni_port.get_port())
self._unis[uni_port.port_number] = uni_port
self.openomci.onu_omci_device.alarm_synchronizer.set_alarm_params(
onu_id=self.proxy_address.onu_id,
uni_ports=self._unis.values())
# TODO: this should be in the PonPort class
pon_port = self._pon.get_port()
self.adapter_agent.delete_port_reference_from_parent(
self.device_id, pon_port)
# Find index where this ONU peer is (should almost always be zero)
d = [
i for i, e in enumerate(pon_port.peers)
if e.port_no == intf_id and e.device_id == device.parent_id
]
if len(d) > 0:
pon_port.peers[d[0]].port_no = uni_port.port_number
self.adapter_agent.add_port_reference_to_parent(
self.device_id, pon_port)
yield self.adapter_agent.device_update(device)
uni_port.enabled = True
uni_id += 1
def __init__(self, adapter, device_id):
self.log = structlog.get_logger(device_id=device_id)
self.log.debug('function-entry')
self.adapter = adapter
self.core_proxy = adapter.core_proxy
self.adapter_proxy = adapter.adapter_proxy
self.parent_adapter = None
self.parent_id = None
self.device_id = device_id
self.incoming_messages = DeferredQueue()
self.event_messages = DeferredQueue()
self.proxy_address = None
self.tx_id = 0
self._enabled = False
self.alarms = None
self.pm_metrics = None
self._omcc_version = OMCCVersion.Unknown
self._total_tcont_count = 0 # From ANI-G ME
self._qos_flexibility = 0 # From ONT2_G ME
self._onu_indication = None
self._unis = dict() # Port # -> UniPort
self._pon = None
# TODO: probably shouldnt be hardcoded, determine from olt maybe?
self._pon_port_number = 100
self.logical_device_id = None
self._heartbeat = HeartBeat.create(self, device_id)
# Set up OpenOMCI environment
self._onu_omci_device = None
self._dev_info_loaded = False
self._deferred = None
self._in_sync_subscription = None
self._connectivity_subscription = None
self._capabilities_subscription = None
self.mac_bridge_service_profile_entity_id = 0x201
self.gal_enet_profile_entity_id = 0x1
self._tp_service_specific_task = dict()
self._tech_profile_download_done = dict()
# Initialize KV store client
self.args = registry('main').get_args()
if self.args.backend == 'etcd':
host, port = self.args.etcd.split(':', 1)
self.kv_client = EtcdStore(host, port,
TechProfile.KV_STORE_TECH_PROFILE_PATH_PREFIX)
elif self.args.backend == 'consul':
host, port = self.args.consul.split(':', 1)
self.kv_client = ConsulStore(host, port,
TechProfile.KV_STORE_TECH_PROFILE_PATH_PREFIX)
else:
self.log.error('Invalid-backend')
raise Exception("Invalid-backend-for-kv-store")
def __init__(self, omci_agent):
"""
Class initializer
:param omci_agent: (OpenOMCIAgent) OpenOMCI Agent
"""
super(AlarmDbExternal, self).__init__(omci_agent)
self.args = registry('main').get_args()
host, port = self.args.etcd.split(':', 1)
self._kv_store = EtcdStore(host, port, AlarmDbExternal.ALARM_PATH)
def __init__(self, adapter, device_id):
self.adapter = adapter
self.adapter_agent = adapter.adapter_agent
self.device_id = device_id
self.log = structlog.get_logger(device_id=device_id)
self.logical_device_id = None
self.proxy_address = None
self._enabled = False
self.pm_metrics = None
self.alarms = None
self._openomci = OMCI(self, adapter.omci_agent)
self._in_sync_subscription = None
self._pon_port_number = 1
self._unis = dict() # Port # -> UniPort
self._pon = PonPort.create(self, self._pon_port_number)
self._heartbeat = HeartBeat.create(self, device_id)
self._deferred = None
# Flow entries
self._flows = dict()
# OMCI resources # TODO: Some of these could be dynamically chosen
self.vlan_tcis_1 = 0x900
self.mac_bridge_service_profile_entity_id = self.vlan_tcis_1
self.gal_enet_profile_entity_id = 0
# Technology profile related values
self.incoming_messages = DeferredQueue()
self.event_messages = DeferredQueue()
self._tp_service_specific_task = dict()
self._tech_profile_download_done = dict()
# Initialize KV store client
self.args = registry('main').get_args()
if self.args.backend == 'etcd':
host, port = self.args.etcd.split(':', 1)
self.kv_client = EtcdClient(
host, port, TechProfile.KV_STORE_TECH_PROFILE_PATH_PREFIX)
elif self.args.backend == 'consul':
host, port = self.args.consul.split(':', 1)
self.kv_client = Consul(
host, port, TechProfile.KV_STORE_TECH_PROFILE_PATH_PREFIX)
else:
self.log.error('Invalid-backend')
raise Exception("Invalid-backend-for-kv-store")
# Handle received ONU event messages
reactor.callLater(0, self.handle_onu_events)
def __init__(self, adapter, device_id):
self.adapter = adapter
self.core_proxy = adapter.core_proxy
self.adapter_proxy = adapter.adapter_proxy
self.device_id = device_id
self.log = structlog.get_logger(device_id=device_id)
self.channel = None
self.io_port = None
self.logical_device_id = None
self.nni_port = None
self.ofp_port_no = None
self.interface = registry('main').get_args().interface
self.pm_metrics = None
self.alarms = None
self.frames = None
def __init__(self, core_proxy, adapter_proxy, config):
self.core_proxy = core_proxy
self.adapter_proxy = adapter_proxy
self.config = config
self.descriptor = Adapter(
id=self.name,
vendor='OLT white box vendor',
version='0.1',
config=AdapterConfig(log_level=LogLevel.INFO)
)
log.debug('openolt.__init__', core_proxy=core_proxy, adapter_proxy=adapter_proxy)
self.devices = dict() # device_id -> OpenoltDevice()
self.interface = registry('main').get_args().interface
self.logical_device_id_to_root_device_id = dict()
self.num_devices = 0
def __init__(self, omci_agent):
"""
Class initializer
:param omci_agent: (OpenOMCIAgent) OpenOMCI Agent
"""
super(AlarmDbExternal, self).__init__(omci_agent)
self._core = omci_agent.core_proxy
# Some statistics to help with debug/tuning/...
self._statistics = {
'get': MibDbStatistic('get'),
'set': MibDbStatistic('set'),
'create': MibDbStatistic('create'),
'delete': MibDbStatistic('delete')
}
self.args = registry('main').get_args()
host, port = self.args.etcd.split(':', 1)
self._kv_store = EtcdStore(host, port, AlarmDbExternal.ALARM_PATH)
def __init__(self, vendor_id, equipment_id, software_version,
serial_number, mac_address):
self.log = structlog.get_logger()
self._jsonstring = b''
# lookup keys
self._vendor_id = vendor_id
self._equipment_id = equipment_id
self._software_version = software_version
# replacement values
self._serial_number = serial_number
self._mac_address = mac_address
self.args = registry('main').get_args()
host, port = self.args.etcd.split(':', 1)
self._kv_store = TwistedEtcdStore(host, port, MibTemplateDb.BASE_PATH)
self.loaded = False
def __init__(self, resource_mgr):
try:
self.args = registry('main').get_args()
self.resource_mgr = resource_mgr
if self.args.backend == 'etcd':
# KV store's IP Address and PORT
host, port = self.args.etcd.split(':', 1)
self._kv_store = EtcdStore(
host, port, TechProfile.KV_STORE_TECH_PROFILE_PATH_PREFIX)
elif self.args.backend == 'consul':
# KV store's IP Address and PORT
host, port = self.args.consul.split(':', 1)
self._kv_store = ConsulStore(
host, port, TechProfile.KV_STORE_TECH_PROFILE_PATH_PREFIX)
# self.tech_profile_instance_store = dict()
except Exception as e:
log.exception("exception-in-init")
raise Exception(e)
def __init__(self, device_id, host_and_port, extra_args, device_info):
self.log = structlog.get_logger(id=device_id,
ip=host_and_port)
self.device_id = device_id
self.host_and_port = host_and_port
self.extra_args = extra_args
self.device_info = device_info
self.args = registry('main').get_args()
self._path_prefix = AdtranOltResourceMgr.BASE_PATH_KV_STORE.format(device_id)
# KV store's IP Address and PORT
# host, port = '127.0.0.1', 8500
if self.args.backend == 'etcd':
host, port = self.args.etcd.split(':', 1)
self.kv_store = create_kv_client('etcd', host, port)
# self.kv_store = EtcdStore(host, port,
# AdtranOltResourceMgr.BASE_PATH_KV_STORE.format(device_id))
elif self.args.backend == 'consul':
host, port = self.args.consul.split(':', 1)
self.kv_store = create_kv_client('consul', host, port)
# self.kv_store = ConsulStore(host, port,
# AdtranOltResourceMgr.BASE_PATH_KV_STORE.format(device_id))
else:
self.log.error('Invalid-backend')
raise Exception("Invalid-backend-for-kv-store")
self.resource_mgr = AdtranPONResourceManager(
self.device_info.technology,
self.extra_args,
self.device_id, self.args.backend,
host, port
)
# Tech profiles uses this resource manager to retrieve information on a per-interface
# basis
self.resource_managers = {intf_id: self.resource_mgr for intf_id in device_info.intf_ids}
# Flag to indicate whether information fetched from device should
# be used to initialize PON Resource Ranges
self.use_device_info = False
self.initialize_device_resource_range_and_pool()
def __init__(self, device_id, host_and_port, extra_args, device_info):
self.log = structlog.get_logger(id=device_id, ip=host_and_port)
self.device_id = device_id
self.host_and_port = host_and_port
self.extra_args = extra_args
self.device_info = device_info
self.args = registry('main').get_args()
# KV store's IP Address and PORT
if self.args.backend == 'etcd':
host, port = self.args.etcd.split(':', 1)
self.kv_store = EtcdStore(
host, port,
OpenOltResourceMgr.BASE_PATH_KV_STORE.format(device_id))
elif self.args.backend == 'consul':
host, port = self.args.consul.split(':', 1)
self.kv_store = ConsulStore(
host, port,
OpenOltResourceMgr.BASE_PATH_KV_STORE.format(device_id))
else:
self.log.error('Invalid-backend')
raise Exception("Invalid-backend-for-kv-store")
ranges = dict()
resource_mgrs_by_tech = dict()
self.resource_mgrs = dict()
# If a legacy driver returns protobuf without any ranges,s synthesize one from
# the legacy global per-device informaiton. This, in theory, is temporary until
# the legacy drivers are upgrade to support pool ranges.
if len(self.device_info.ranges) == 0:
arange = self.device_info.ranges.add()
arange.technology = self.device_info.technology
arange.intf_ids.extend(range(0, device_info.pon_ports))
pool = arange.pools.add()
pool.type = openolt_pb2.DeviceInfo.DeviceResourceRanges.Pool.ONU_ID
pool.start = self.device_info.onu_id_start
pool.end = self.device_info.onu_id_end
pool.sharing = openolt_pb2.DeviceInfo.DeviceResourceRanges.Pool.DEDICATED_PER_INTF
pool = arange.pools.add()
pool.type = openolt_pb2.DeviceInfo.DeviceResourceRanges.Pool.ALLOC_ID
pool.start = self.device_info.alloc_id_start
pool.end = self.device_info.alloc_id_end
pool.sharing = openolt_pb2.DeviceInfo.DeviceResourceRanges.Pool.SHARED_BY_ALL_INTF_ALL_TECH
pool = arange.pools.add()
pool.type = openolt_pb2.DeviceInfo.DeviceResourceRanges.Pool.GEMPORT_ID
pool.start = self.device_info.gemport_id_start
pool.end = self.device_info.gemport_id_end
pool.sharing = openolt_pb2.DeviceInfo.DeviceResourceRanges.Pool.SHARED_BY_ALL_INTF_ALL_TECH
pool = arange.pools.add()
pool.type = openolt_pb2.DeviceInfo.DeviceResourceRanges.Pool.FLOW_ID
pool.start = self.device_info.flow_id_start
pool.end = self.device_info.flow_id_end
pool.sharing = openolt_pb2.DeviceInfo.DeviceResourceRanges.Pool.SHARED_BY_ALL_INTF_ALL_TECH
# Create a separate Resource Manager instance for each range. This assumes that
# each technology is represented by only a single range
global_resource_mgr = None
for arange in self.device_info.ranges:
technology = arange.technology
self.log.info("device-info", technology=technology)
ranges[technology] = arange
extra_args = self.extra_args + ' ' + PONResourceManager.OLT_MODEL_ARG + ' {}'.format(
self.device_info.model)
resource_mgr = PONResourceManager(technology, extra_args,
self.device_id,
self.args.backend, host, port)
resource_mgrs_by_tech[technology] = resource_mgr
if global_resource_mgr is None:
global_resource_mgr = resource_mgr
for intf_id in arange.intf_ids:
self.resource_mgrs[intf_id] = resource_mgrs_by_tech[technology]
self.initialize_device_resource_range_and_pool(
resource_mgr, global_resource_mgr, arange)
# After we have initialized resource ranges, initialize the
# resource pools accordingly.
for technology, resource_mgr in resource_mgrs_by_tech.iteritems():
resource_mgr.init_device_resource_pool()
