blob: 6ed10a9bbafe913d00ef171d23e955f680424d35 [file] [log] [blame]
#
# 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.
#
"""
Mock device adapter for testing.
"""
from uuid import uuid4
import arrow
import structlog
from klein import Klein
from scapy.layers.l2 import Ether, EAPOL, Padding
from twisted.internet import endpoints
from twisted.internet import reactor
from twisted.internet.defer import inlineCallbacks
from twisted.internet.task import LoopingCall
from twisted.web.server import Site
from zope.interface import implementer
from common.utils.asleep import asleep
from voltha.adapters.interface import IAdapterInterface
from voltha.core.flow_decomposer import *
from voltha.core.logical_device_agent import mac_str_to_tuple
from voltha.protos.adapter_pb2 import Adapter, AdapterConfig
from voltha.protos.device_pb2 import DeviceType, DeviceTypes, Device, Port, \
PmConfigs, PmConfig, PmGroupConfig
from voltha.protos.events_pb2 import KpiEvent, KpiEventType, MetricValuePairs
from voltha.protos.health_pb2 import HealthStatus
from voltha.protos.common_pb2 import LogLevel, OperStatus, ConnectStatus, \
AdminState
from voltha.protos.logical_device_pb2 import LogicalDevice, LogicalPort
from voltha.protos.openflow_13_pb2 import ofp_desc, ofp_port, OFPPF_1GB_FD, \
OFPPF_FIBER, OFPPS_LIVE, ofp_switch_features, OFPC_PORT_STATS, \
OFPC_GROUP_STATS, OFPC_TABLE_STATS, OFPC_FLOW_STATS
from voltha.protos.events_pb2 import AlarmEvent, AlarmEventType, \
AlarmEventSeverity, AlarmEventState, AlarmEventCategory
import sys
log = structlog.get_logger()
class AdapterPmMetrics:
class Metrics:
def __init__(self, config, value):
self.config = config
self.value = value
def __init__(self,device):
self.pm_names = {'tx_64_pkts','tx_65_127_pkts', 'tx_128_255_pkts',
'tx_256_511_pkts', 'tx_512_1023_pkts',
'tx_1024_1518_pkts', 'tx_1519_9k_pkts', 'rx_64_pkts',
'rx_65_127_pkts', 'rx_128_255_pkts', 'rx_256_511_pkts',
'rx_512_1023_pkts', 'rx_1024_1518_pkts',
'rx_1519_9k_pkts', 'tx_pkts', 'rx_pkts',
'tx_bytes', 'rx_bytes'}
# This is just to generate more realistic looking values. This would
# not be implemented in a normal adapter.
self.rand_ranges = dict (
tx_64_pkts=[50, 55],
tx_65_127_pkts=[55,60],
tx_128_255_pkts=[60,65],
tx_256_511_pkts=[85,90],
tx_512_1023_pkts=[90,95],
tx_1024_1518_pkts=[60,65],
tx_1519_9k_pkts=[50,55],
rx_64_pkts=[50, 55],
rx_65_127_pkts=[55,60],
rx_128_255_pkts=[60,65],
rx_256_511_pkts=[85,90],
rx_512_1023_pkts=[90,95],
rx_1024_1518_pkts=[60,65],
rx_1519_9k_pkts=[50,55],
tx_pkts=[90,100],
rx_pkts=[90,100],
rx_bytes=[90000,100000],
tx_bytes=[90000,100000]
)
self.device = device
self.id = device.id
self.default_freq = 150
self.grouped = False
self.freq_override = False
self.pon_metrics = dict()
self.nni_metrics = dict()
self.lc = None
for m in self.pm_names:
self.pon_metrics[m] = \
self.Metrics(config = PmConfig(name=m,
type=PmConfig.COUNTER,
enabled=True), value = 0)
self.nni_metrics[m] = \
self.Metrics(config = PmConfig(name=m,
type=PmConfig.COUNTER,
enabled=True), value = 0)
def update(self, pm_config):
if self.default_freq != pm_config.default_freq:
# Update the callback to the new frequency.
self.default_freq = pm_config.default_freq
self.lc.stop()
self.lc.start(interval=self.default_freq/10)
for m in pm_config.metrics:
self.pon_metrics[m.name].config.enabled = m.enabled
self.nni_metrics[m.name].config.enabled = m.enabled
def make_proto(self):
pm_config = PmConfigs(
id=self.id,
default_freq=self.default_freq,
grouped = False,
freq_override = False)
for m in sorted(self.pon_metrics):
pm=self.pon_metrics[m]
pm_config.metrics.extend([PmConfig(name=pm.config.name,
type=pm.config.type,
enabled=pm.config.enabled)])
return pm_config
def collect_pon_metrics(self):
import random
rtrn_pon_metrics = dict()
for m in self.pm_names:
if self.pon_metrics[m].config.enabled:
self.pon_metrics[m].value += \
random.randint(self.rand_ranges[m][0], self.rand_ranges[m][1])
rtrn_pon_metrics[m] = self.pon_metrics[m].value
return rtrn_pon_metrics
def collect_nni_metrics(self):
import random
rtrn_nni_metrics = dict()
for m in self.pm_names:
if self.nni_metrics[m].config.enabled:
self.nni_metrics[m].value += \
random.randint(self.rand_ranges[m][0], self.rand_ranges[m][1])
rtrn_nni_metrics[m] = self.nni_metrics[m].value
return rtrn_nni_metrics
def start_collector(self, device_name, device_id, callback):
prefix = 'voltha.{}.{}'.format(device_name, device_id)
self.lc = LoopingCall(callback, device_id, prefix)
self.lc.start(interval=self.default_freq/10)
@implementer(IAdapterInterface)
class SimulatedOltAdapter(object):
name = 'simulated_olt'
supported_device_types = [
DeviceType(
id='simulated_olt',
adapter=name,
accepts_bulk_flow_update=True
)
]
app = Klein()
def __init__(self, adapter_agent, config):
self.adapter_agent = adapter_agent
self.config = config
self.descriptor = Adapter(
id=self.name,
vendor='Voltha project',
version='0.1',
config=AdapterConfig(log_level=LogLevel.INFO)
)
self.control_endpoint = None
# Faked PM metrics for testing PM functionality
self.pm_metrics = None
def start(self):
log.debug('starting')
# setup a basic web server for test control
self.control_endpoint = endpoints.TCP4ServerEndpoint(reactor, 18880)
self.control_endpoint.listen(self.get_test_control_site())
# TODO tmp: populate some devices and logical devices
# reactor.callLater(0, self._tmp_populate_stuff)
log.info('started')
def stop(self):
log.debug('stopping')
log.info('stopped')
def adapter_descriptor(self):
return self.descriptor
def device_types(self):
return DeviceTypes(items=self.supported_device_types)
def health(self):
return HealthStatus(state=HealthStatus.HealthState.HEALTHY)
def change_master_state(self, master):
raise NotImplementedError()
def adopt_device(self, device):
# We kick of a simulated activation scenario
reactor.callLater(0.2, self._simulate_device_activation, device)
return device
def abandon_device(self, device):
raise NotImplementedError()
def disable_device(self, device):
raise NotImplementedError()
def reenable_device(self, device):
raise NotImplementedError()
def reboot_device(self, device):
raise NotImplementedError()
def delete_device(self, device):
raise NotImplementedError()
def get_device_details(self, device):
raise NotImplementedError()
def update_pm_config(self, device, pm_config):
log.info("adapter-update-pm-config", device=device, pm_config=pm_config)
self.pm_metrics.update(pm_config)
def _tmp_populate_stuff(self):
"""
pretend that we discovered some devices and create:
- devices
- device ports for each
- logical device
- logical device ports
"""
olt = Device(
id='simulated_olt_1',
type='simulated_olt',
root=True,
vendor='simulated',
model='n/a',
hardware_version='n/a',
firmware_version='n/a',
software_version='1.0',
serial_number=uuid4().hex,
adapter=self.name,
oper_status=OperStatus.DISCOVERED
)
self.adapter_agent.add_device(olt)
self.adapter_agent.add_port(
olt.id, Port(port_no=1, label='pon', type=Port.PON_OLT))
self.adapter_agent.add_port(
olt.id, Port(port_no=2, label='eth', type=Port.ETHERNET_NNI))
onu1 = Device(
id='simulated_onu_1',
type='simulated_onu',
root=False,
parent_id=olt.id,
parent_port_no=1,
vendor='simulated',
model='n/a',
hardware_version='n/a',
firmware_version='n/a',
software_version='1.0',
serial_number=uuid4().hex,
adapter='simulated_onu',
oper_status=OperStatus.DISCOVERED,
vlan=101
)
self.adapter_agent.add_device(onu1)
self.adapter_agent.add_port(onu1.id, Port(
port_no=2, label='eth', type=Port.ETHERNET_UNI))
self.adapter_agent.add_port(onu1.id, Port(
port_no=1,
label='pon',
type=Port.PON_ONU,
peers=[Port.PeerPort(device_id=olt.id, port_no=1)]))
onu2 = Device(
id='simulated_onu_2',
type='simulated_onu',
root=False,
parent_id=olt.id,
parent_port_no=1,
vendor='simulated',
model='n/a',
hardware_version='n/a',
firmware_version='n/a',
software_version='1.0',
serial_number=uuid4().hex,
adapter='simulated_onu',
oper_status=OperStatus.DISCOVERED,
vlan=102
)
self.adapter_agent.add_device(onu2)
self.adapter_agent.add_port(onu2.id, Port(
port_no=2, label='eth', type=Port.ETHERNET_UNI))
self.adapter_agent.add_port(onu2.id, Port(
port_no=1,
label='pon',
type=Port.PON_ONU,
peers=[Port.PeerPort(device_id=olt.id, port_no=1)]))
ld = LogicalDevice(
id='simulated1',
datapath_id=1,
desc=ofp_desc(
mfr_desc='cord project',
hw_desc='simualted pon',
sw_desc='simualted pon',
serial_num=uuid4().hex,
dp_desc='n/a'
),
switch_features=ofp_switch_features(
n_buffers=256, # TODO fake for now
n_tables=2, # TODO ditto
capabilities=( # TODO and ditto
OFPC_FLOW_STATS
| OFPC_TABLE_STATS
| OFPC_PORT_STATS
| OFPC_GROUP_STATS
)
),
root_device_id=olt.id
)
self.adapter_agent.create_logical_device(ld)
cap = OFPPF_1GB_FD | OFPPF_FIBER
for port_no, name, device_id, device_port_no, root_port in [
(1, 'onu1', onu1.id, 2, False),
(2, 'onu2', onu2.id, 2, False),
(129, 'olt1', olt.id, 2, True)]:
port = LogicalPort(
id=name,
ofp_port=ofp_port(
port_no=port_no,
hw_addr=mac_str_to_tuple('00:00:00:00:00:%02x' % port_no),
name=name,
config=0,
state=OFPPS_LIVE,
curr=cap,
advertised=cap,
peer=cap,
curr_speed=OFPPF_1GB_FD,
max_speed=OFPPF_1GB_FD
),
device_id=device_id,
device_port_no=device_port_no,
root_port=root_port
)
self.adapter_agent.add_logical_port(ld.id, port)
olt.parent_id = ld.id
self.adapter_agent.update_device(olt)
@inlineCallbacks
def _simulate_device_activation(self, device):
# first we pretend that we were able to contact the device and obtain
# additional information about it
device.root = True
device.vendor = 'simulated'
device.model = 'n/a'
device.hardware_version = 'n/a'
device.firmware_version = 'n/a'
device.software_version = '1.0'
device.serial_number = uuid4().hex
device.connect_status = ConnectStatus.REACHABLE
self.adapter_agent.update_device(device)
# Now set the initial PM configuration for this device
self.pm_metrics=AdapterPmMetrics(device)
pm_config = self.pm_metrics.make_proto()
log.info("initial-pm-config", pm_config=pm_config)
self.adapter_agent.update_device_pm_config(pm_config,init=True)
# then shortly after we create some ports for the device
yield asleep(0.05)
nni_port = Port(
port_no=2,
label='NNI facing Ethernet port',
type=Port.ETHERNET_NNI,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE
)
self.adapter_agent.add_port(device.id, nni_port)
self.adapter_agent.add_port(device.id, Port(
port_no=1,
label='PON port',
type=Port.PON_OLT,
admin_state=AdminState.ENABLED,
oper_status=OperStatus.ACTIVE
))
# then shortly after we create the logical device with one port
# that will correspond to the NNI port
yield asleep(0.05)
logical_device_id = uuid4().hex[:12]
ld = LogicalDevice(
# not setting id and datapth_id will let the adapter agent pick id
desc=ofp_desc(
mfr_desc='cord porject',
hw_desc='simualted pon',
sw_desc='simualted pon',
serial_num=uuid4().hex,
dp_desc='n/a'
),
switch_features=ofp_switch_features(
n_buffers=256, # TODO fake for now
n_tables=2, # TODO ditto
capabilities=( # TODO and ditto
OFPC_FLOW_STATS
| OFPC_TABLE_STATS
| OFPC_PORT_STATS
| OFPC_GROUP_STATS
)
),
root_device_id=device.id
)
ld_initialized = self.adapter_agent.create_logical_device(ld)
cap = OFPPF_1GB_FD | OFPPF_FIBER
self.adapter_agent.add_logical_port(ld_initialized.id, LogicalPort(
id='nni',
ofp_port=ofp_port(
port_no=129,
hw_addr=mac_str_to_tuple('00:00:00:00:00:%02x' % 129),
name='nni',
config=0,
state=OFPPS_LIVE,
curr=cap,
advertised=cap,
peer=cap,
curr_speed=OFPPF_1GB_FD,
max_speed=OFPPF_1GB_FD
),
device_id=device.id,
device_port_no=nni_port.port_no,
root_port=True
))
# and finally update to active
device = self.adapter_agent.get_device(device.id)
device.parent_id = ld_initialized.id
device.oper_status = OperStatus.ACTIVE
self.adapter_agent.update_device(device)
# reactor.callLater(0.1, self._simulate_detection_of_onus, device.id)
self.start_kpi_collection(device.id)
self.start_alarm_simulation(device.id)
@inlineCallbacks
def _simulate_detection_of_onus(self, device_id):
for i in xrange(1, 5):
log.info('activate-olt-for-onu-{}'.format(i))
vlan_id = self._olt_side_onu_activation(i)
yield asleep(0.05)
self.adapter_agent.child_device_detected(
parent_device_id=device_id,
parent_port_no=1,
child_device_type='simulated_onu',
proxy_address=Device.ProxyAddress(
device_id=device_id,
channel_id=vlan_id
),
vlan=vlan_id
)
def _olt_side_onu_activation(self, seq):
"""
This is where if this was a real OLT, the OLT-side activation for
the new ONU should be performed. By the time we return, the OLT shall
be able to provide tunneled (proxy) communication to the given ONU,
using the returned information.
"""
vlan_id = seq + 100
return vlan_id
#def update_pm_collection(self, device, pm_collection_config):
# This is where the metrics to be collected are configured and where
# the sampling frequency is set.
#TODO: Here.
# pass
def update_flows_bulk(self, device, flows, groups):
log.debug('bulk-flow-update', device_id=device.id,
flows=flows, groups=groups)
# sample code that analyzes the incoming flow table
assert len(groups.items) == 0, "Cannot yet deal with groups"
for flow in flows.items:
in_port = get_in_port(flow)
assert in_port is not None
if in_port == 2:
# Downstream rule
for field in get_ofb_fields(flow):
if field.type == ETH_TYPE:
_type = field.eth_type
pass # construct ether type based condition here
elif field.type == IP_PROTO:
_proto = field.ip_proto
pass # construct ip_proto based condition here
elif field.type == IN_PORT:
_port = field.port
pass # construct in_port based condition here
elif field.type == VLAN_VID:
_vlan_vid = field.vlan_vid
pass # construct VLAN ID based filter condition here
elif field.type == VLAN_PCP:
_vlan_pcp = field.vlan_pcp
pass # construct VLAN PCP based filter condition here
elif field.type == METADATA:
pass # safe to ignore
# TODO
else:
raise NotImplementedError('field.type={}'.format(
field.type))
for action in get_actions(flow):
if action.type == OUTPUT:
pass # construct packet emit rule here
elif action.type == PUSH_VLAN:
if action.push.ethertype != 0x8100:
log.error('unhandled-ether-type',
ethertype=action.push.ethertype)
pass # construct vlan push command here
elif action.type == POP_VLAN:
pass # construct vlan pop command here
elif action.type == SET_FIELD:
assert (action.set_field.field.oxm_class ==
ofp.OFPXMC_OPENFLOW_BASIC)
field = action.set_field.field.ofb_field
if field.type == VLAN_VID:
pass # construct vlan_id set command here
else:
log.error('unsupported-action-set-field-type',
field_type=field.type)
else:
log.error('unsupported-action-type',
action_type=action.type)
# final assembly of low level device flow rule and pushing it
# down to device
pass
elif in_port == 1:
# Upstream rule
for field in get_ofb_fields(flow):
if field.type == ETH_TYPE:
_type = field.eth_type
pass # construct ether type based condition here
elif field.type == IP_PROTO:
_proto = field.ip_proto
pass # construct ip_proto based condition here
elif field.type == IN_PORT:
_port = field.port
pass # construct in_port based condition here
elif field.type == VLAN_VID:
_vlan_vid = field.vlan_vid
pass # construct VLAN ID based filter condition here
elif field.type == VLAN_PCP:
_vlan_pcp = field.vlan_pcp
pass # construct VLAN PCP based filter condition here
elif field.type == UDP_SRC:
_udp_src = field.udp_src
pass # construct UDP SRC based filter here
elif field.type == UDP_DST:
_udp_dst = field.udp_dst
pass # construct UDP DST based filter here
# TODO
else:
raise NotImplementedError('field.type={}'.format(
field.type))
for action in get_actions(flow):
if action.type == OUTPUT:
pass # construct packet emit rule here
elif action.type == PUSH_VLAN:
if action.push.ethertype != 0x8100:
log.error('unhandled-ether-type',
ethertype=action.push.ethertype)
pass # construct vlan push command here
elif action.type == SET_FIELD:
assert (action.set_field.field.oxm_class ==
ofp.OFPXMC_OPENFLOW_BASIC)
field = action.set_field.field.ofb_field
if field.type == VLAN_VID:
pass # construct vlan_id set command here
else:
log.error('unsupported-action-set-field-type',
field_type=field.type)
else:
log.error('unsupported-action-type',
action_type=action.type)
# final assembly of low level device flow rule and pushing it
# down to device
pass
else:
raise Exception('Port should be 1 or 2 by our convention')
def update_flows_incrementally(self, device, flow_changes, group_changes):
raise NotImplementedError()
def send_proxied_message(self, proxy_address, msg):
log.info('send-proxied-message', proxy_address=proxy_address, msg=msg)
# we mimic a response by sending the same message back in a short time
reactor.callLater(
0.2,
self.adapter_agent.receive_proxied_message,
proxy_address,
msg
)
def receive_proxied_message(self, proxy_address, msg):
raise NotImplementedError()
def receive_packet_out(self, logical_device_id, egress_port_no, msg):
log.info('packet-out', logical_device_id=logical_device_id,
egress_port_no=egress_port_no, msg_len=len(msg))
def start_kpi_collection(self, device_id):
"""Simulate periodic KPI metric collection from the device"""
import random
@inlineCallbacks # pretend that we need to do async calls
def _collect(device_id, prefix):
try:
# Step 1: gather metrics from device (pretend it here) - examples
# upgraded the metrics to include packet statistics for
# testing.
nni_port_metrics = self.pm_metrics.collect_nni_metrics()
pon_port_metrics = self.pm_metrics.collect_pon_metrics()
olt_metrics = yield dict(
cpu_util=20 + 5 * random.random(),
buffer_util=10 + 10 * random.random()
)
# Step 2: prepare the KpiEvent for submission
# we can time-stamp them here (or could use time derived from OLT
ts = arrow.utcnow().timestamp
kpi_event = KpiEvent(
type=KpiEventType.slice,
ts=ts,
prefixes={
# OLT-level
prefix: MetricValuePairs(metrics=olt_metrics),
# OLT NNI port
prefix + '.nni': MetricValuePairs(
metrics=nni_port_metrics),
# OLT PON port
prefix + '.pon': MetricValuePairs(
metrics=pon_port_metrics)
}
)
# Step 3: submit
self.adapter_agent.submit_kpis(kpi_event)
except Exception as e:
log.exception('failed-to-submit-kpis', e=e)
self.pm_metrics.start_collector(self.name, device_id ,_collect)
#prefix = 'voltha.{}.{}'.format(self.name, device_id)
#lc = LoopingCall(_collect, device_id, prefix)
#lc.start(interval=15) # TODO make this configurable
def start_alarm_simulation(self, device_id):
"""Simulate periodic device alarms"""
import random
def _generate_alarm(device_id):
try:
# Randomly choose values for each enum types
severity = random.choice(list(
v for k, v in
AlarmEventSeverity.DESCRIPTOR.enum_values_by_name.items()))
state = random.choice(list(
v for k, v in
AlarmEventState.DESCRIPTOR.enum_values_by_name.items()))
type = random.choice(list(
v for k, v in
AlarmEventType.DESCRIPTOR.enum_values_by_name.items()))
category = random.choice(list(
v for k, v in
AlarmEventCategory.DESCRIPTOR.enum_values_by_name.items()))
description = "Simulated alarm - " \
"device:{} " \
"type:{} " \
"severity:{} " \
"state:{} " \
"category:{}".format(device_id,
type.name,
severity.name,
state.name,
category.name)
current_context = {}
for key, value in self.__dict__.items():
current_context[key] = str(value)
alarm_event = self.adapter_agent.create_alarm(
resource_id=device_id,
type=type.number,
category=category.number,
severity=severity.number,
state=state.number,
description=description,
context=current_context)
self.adapter_agent.submit_alarm(device_id, alarm_event)
except Exception as e:
log.exception('failed-to-submit-alarm', e=e)
alarm_lc = LoopingCall(_generate_alarm, device_id)
alarm_lc.start(30)
# ~~~~~~~~~~~~~~~~~~~~ Embedded test Klein rest server ~~~~~~~~~~~~~~~~~~~~
def get_test_control_site(self):
return Site(self.app.resource())
@app.route('/devices/<string:device_id>/detect_onus')
def detect_onus(self, request, device_id):
log.info('detect-onus', request=request, device_id=device_id)
self._simulate_detection_of_onus(device_id)
return '{"status": "OK"}'
@app.route('/devices/<string:device_id>/test_eapol_in')
def test_eapol_in(self, request, device_id):
"""Simulate a packet in message posted upstream"""
log.info('test_eapol_in', request=request, device_id=device_id)
eapol_start = str(
Ether(src='00:11:22:33:44:55') /
EAPOL(type=1, len=0) /
Padding(load=42 * '\x00')
)
device = self.adapter_agent.get_device(device_id)
self.adapter_agent.send_packet_in(logical_device_id=device.parent_id,
logical_port_no=1,
packet=eapol_start)
return '{"status": "sent"}'