def __init__(self, technology, device_id, backend, host, port):
"""
Create ResourceKvStore object.
Based on backend ('consul' and 'etcd' use the host and port
to create the respective object.
:param technology: PON technology
:param device_id: OLT device id
:param backend: Type of backend storage (etcd or consul)
:param host: host ip info for backend storage
:param port: port for the backend storage
:raises exception when invalid backend store passed as an argument
"""
# logger
self._log = structlog.get_logger()
path = PATH_PREFIX.format(technology)
try:
if backend == 'consul':
self._kv_store = ConsulStore(host, port, path)
elif backend == 'etcd':
self._kv_store = EtcdStore(host, port, path)
else:
self._log.error('Invalid-backend')
raise Exception("Invalid-backend-for-kv-store")
except Exception as e:
self._log.exception("exception-in-init")
raise Exception(e)
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, omci_agent):
"""
Class initializer
:param omci_agent: (OpenOMCIAgent) OpenOMCI Agent
"""
super(MibDbExternal, 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, MibDbExternal.MIB_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 = EtcdStore(host, port, MibTemplateDb.BASE_PATH)
self.loaded = False
self._load_template()
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()
# 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()
def create_kv_client(self):
client = EtcdStore(self.etcd_host, self.etcd_port,
KV_STORE_DATA_PATH_PREFIX)
LogController.etcd_client = client
return client