| # |
| # Copyright 2018 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 json |
| import ast |
| from collections import namedtuple |
| import structlog |
| from enum import Enum |
| |
| from voltha.core.config.config_backend import ConsulStore |
| from voltha.core.config.config_backend import EtcdStore |
| from voltha.registry import registry |
| from voltha.adapters.openolt.protos import openolt_pb2 |
| |
| # logger |
| log = structlog.get_logger() |
| |
| DEFAULT_TECH_PROFILE_TABLE_ID = 64 |
| |
| # Enums used while creating TechProfileInstance |
| Direction = Enum('Direction', ['UPSTREAM', 'DOWNSTREAM', 'BIDIRECTIONAL'], |
| start=0) |
| SchedulingPolicy = Enum('SchedulingPolicy', |
| ['WRR', 'StrictPriority', 'Hybrid'], start=0) |
| AdditionalBW = Enum('AdditionalBW', ['None', 'NA', 'BestEffort', 'Auto'], |
| start=0) |
| DiscardPolicy = Enum('DiscardPolicy', |
| ['TailDrop', 'WTailDrop', 'RED', 'WRED'], start=0) |
| InferredAdditionBWIndication = Enum('InferredAdditionBWIndication', |
| ['None', 'NoneAssured', 'BestEffort'], |
| start=0) |
| |
| |
| class InstanceControl(object): |
| # Default value constants |
| ONU_DEFAULT_INSTANCE = 'multi-instance' |
| UNI_DEFAULT_INSTANCE = 'single-instance' |
| DEFAULT_NUM_GEM_PORTS = 1 |
| DEFAULT_GEM_PAYLOAD_SIZE = 'auto' |
| |
| def __init__(self, onu=ONU_DEFAULT_INSTANCE, |
| uni=UNI_DEFAULT_INSTANCE, |
| num_gem_ports=DEFAULT_NUM_GEM_PORTS, |
| max_gem_payload_size=DEFAULT_GEM_PAYLOAD_SIZE): |
| self.onu = onu |
| self.uni = uni |
| self.num_gem_ports = num_gem_ports |
| self.max_gem_payload_size = max_gem_payload_size |
| |
| |
| class Scheduler(object): |
| # Default value constants |
| DEFAULT_ADDITIONAL_BW = 'auto' |
| DEFAULT_PRIORITY = 0 |
| DEFAULT_WEIGHT = 0 |
| DEFAULT_Q_SCHED_POLICY = 'hybrid' |
| |
| def __init__(self, direction, additional_bw=DEFAULT_ADDITIONAL_BW, |
| priority=DEFAULT_PRIORITY, |
| weight=DEFAULT_WEIGHT, |
| q_sched_policy=DEFAULT_Q_SCHED_POLICY): |
| self.direction = direction |
| self.additional_bw = additional_bw |
| self.priority = priority |
| self.weight = weight |
| self.q_sched_policy = q_sched_policy |
| |
| |
| class GemPortAttribute(object): |
| # Default value constants |
| DEFAULT_AES_ENCRYPTION = 'True' |
| DEFAULT_PRIORITY_Q = 0 |
| DEFAULT_WEIGHT = 0 |
| DEFAULT_MAX_Q_SIZE = 'auto' |
| DEFAULT_DISCARD_POLICY = DiscardPolicy.TailDrop.name |
| |
| def __init__(self, pbit_map, discard_config, |
| aes_encryption=DEFAULT_AES_ENCRYPTION, |
| scheduling_policy=SchedulingPolicy.WRR.name, |
| priority_q=DEFAULT_PRIORITY_Q, |
| weight=DEFAULT_WEIGHT, |
| max_q_size=DEFAULT_MAX_Q_SIZE, |
| discard_policy=DiscardPolicy.TailDrop.name): |
| self.max_q_size = max_q_size |
| self.pbit_map = pbit_map |
| self.aes_encryption = aes_encryption |
| self.scheduling_policy = scheduling_policy |
| self.priority_q = priority_q |
| self.weight = weight |
| self.discard_policy = discard_policy |
| self.discard_config = discard_config |
| |
| |
| class DiscardConfig(object): |
| # Default value constants |
| DEFAULT_MIN_THRESHOLD = 0 |
| DEFAULT_MAX_THRESHOLD = 0 |
| DEFAULT_MAX_PROBABILITY = 0 |
| |
| def __init__(self, min_threshold=DEFAULT_MIN_THRESHOLD, |
| max_threshold=DEFAULT_MAX_THRESHOLD, |
| max_probability=DEFAULT_MAX_PROBABILITY): |
| self.min_threshold = min_threshold |
| self.max_threshold = max_threshold |
| self.max_probability = max_probability |
| |
| |
| class TechProfile(object): |
| # Constants used in default tech profile |
| DEFAULT_TECH_PROFILE_NAME = 'Default_1tcont_1gem_Profile' |
| DEFAULT_VERSION = 1.0 |
| DEFAULT_GEMPORTS_COUNT = 1 |
| pbits = ['0b11111111'] |
| |
| # Tech profile path prefix in kv store |
| KV_STORE_TECH_PROFILE_PATH_PREFIX = 'service/voltha/technology_profiles' |
| |
| # Tech profile path in kv store |
| TECH_PROFILE_PATH = '{}/{}' # <technology>/<table_id> |
| |
| # Tech profile instance path in kv store |
| # Format: <technology>/<table_id>/<uni_port_name> |
| TECH_PROFILE_INSTANCE_PATH = '{}/{}/{}' |
| |
| # Tech-Profile JSON String Keys |
| NAME = 'name' |
| PROFILE_TYPE = 'profile_type' |
| VERSION = 'version' |
| NUM_GEM_PORTS = 'num_gem_ports' |
| INSTANCE_CONTROL = 'instance_control' |
| US_SCHEDULER = 'us_scheduler' |
| DS_SCHEDULER = 'ds_scheduler' |
| UPSTREAM_GEM_PORT_ATTRIBUTE_LIST = 'upstream_gem_port_attribute_list' |
| DOWNSTREAM_GEM_PORT_ATTRIBUTE_LIST = 'downstream_gem_port_attribute_list' |
| ONU = 'onu' |
| UNI = 'uni' |
| MAX_GEM_PAYLOAD_SIZE = 'max_gem_payload_size' |
| DIRECTION = 'direction' |
| ADDITIONAL_BW = 'additional_bw' |
| PRIORITY = 'priority' |
| Q_SCHED_POLICY = 'q_sched_policy' |
| WEIGHT = 'weight' |
| PBIT_MAP = 'pbit_map' |
| DISCARD_CONFIG = 'discard_config' |
| MAX_THRESHOLD = 'max_threshold' |
| MIN_THRESHOLD = 'min_threshold' |
| MAX_PROBABILITY = 'max_probability' |
| DISCARD_POLICY = 'discard_policy' |
| PRIORITY_Q = 'priority_q' |
| SCHEDULING_POLICY = 'scheduling_policy' |
| MAX_Q_SIZE = 'max_q_size' |
| AES_ENCRYPTION = 'aes_encryption' |
| |
| 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) |
| |
| class DefaultTechProfile(object): |
| def __init__(self, name, **kwargs): |
| self.name = name |
| self.profile_type = kwargs[TechProfile.PROFILE_TYPE] |
| self.version = kwargs[TechProfile.VERSION] |
| self.num_gem_ports = kwargs[TechProfile.NUM_GEM_PORTS] |
| self.instance_control = kwargs[TechProfile.INSTANCE_CONTROL] |
| self.us_scheduler = kwargs[TechProfile.US_SCHEDULER] |
| self.ds_scheduler = kwargs[TechProfile.DS_SCHEDULER] |
| self.upstream_gem_port_attribute_list = kwargs[ |
| TechProfile.UPSTREAM_GEM_PORT_ATTRIBUTE_LIST] |
| self.downstream_gem_port_attribute_list = kwargs[ |
| TechProfile.DOWNSTREAM_GEM_PORT_ATTRIBUTE_LIST] |
| |
| def to_json(self): |
| return json.dumps(self, default=lambda o: o.__dict__, |
| indent=4) |
| |
| def get_tp_path(self, table_id, uni_port_name): |
| return TechProfile.TECH_PROFILE_INSTANCE_PATH.format( |
| self.resource_mgr.technology, table_id, uni_port_name) |
| |
| def create_tech_profile_instance(self, table_id, uni_port_name, intf_id): |
| tech_profile_instance = None |
| try: |
| # Get tech profile from kv store |
| tech_profile = self._get_tech_profile_from_kv_store(table_id) |
| path = self.get_tp_path(table_id, uni_port_name) |
| |
| if tech_profile is not None: |
| tech_profile = self._get_tech_profile(tech_profile) |
| log.debug( |
| "Created-tech-profile-instance-with-values-from-kvstore") |
| else: |
| tech_profile = self._default_tech_profile() |
| log.debug( |
| "Created-tech-profile-instance-with-default-values") |
| |
| tech_profile_instance = TechProfileInstance( |
| uni_port_name, tech_profile, self.resource_mgr, intf_id) |
| self._add_tech_profile_instance(path, |
| tech_profile_instance.to_json()) |
| except Exception as e: |
| log.exception("Create-tech-profile-instance-failed", exception=e) |
| |
| return tech_profile_instance |
| |
| def get_tech_profile_instance(self, table_id, uni_port_name): |
| # path to fetch tech profile instance json from kv store |
| path = TechProfile.TECH_PROFILE_INSTANCE_PATH.format( |
| self.resource_mgr.technology, table_id, uni_port_name) |
| |
| try: |
| tech_profile_instance = self._kv_store[path] |
| log.debug("Tech-profile-instance-present-in-kvstore", path=path, |
| tech_profile_instance=tech_profile_instance) |
| |
| # Parse JSON into an object with attributes corresponding to dict keys. |
| tech_profile_instance = json.loads(tech_profile_instance, |
| object_hook=lambda d: |
| namedtuple('tech_profile_instance', |
| d.keys())(*d.values())) |
| log.debug("Tech-profile-instance-after-json-to-object-conversion", path=path, |
| tech_profile_instance=tech_profile_instance) |
| return tech_profile_instance |
| except BaseException as e: |
| log.debug("Tech-profile-instance-not-present-in-kvstore", |
| path=path, tech_profile_instance=None, exception=e) |
| return None |
| |
| def delete_tech_profile_instance(self, tp_path): |
| |
| try: |
| del self._kv_store[tp_path] |
| log.debug("Delete-tech-profile-instance-success", path=tp_path) |
| return True |
| except Exception as e: |
| log.debug("Delete-tech-profile-instance-failed", path=tp_path, |
| exception=e) |
| return False |
| |
| def _get_tech_profile_from_kv_store(self, table_id): |
| """ |
| Get tech profile from kv store. |
| |
| :param table_id: reference to get tech profile |
| :return: tech profile if present in kv store else None |
| """ |
| # get tech profile from kv store |
| path = TechProfile.TECH_PROFILE_PATH.format(self.resource_mgr.technology, |
| table_id) |
| try: |
| tech_profile = self._kv_store[path] |
| if tech_profile != '': |
| log.debug("Get-tech-profile-success", tech_profile=tech_profile) |
| return json.loads(tech_profile) |
| # return ast.literal_eval(tech_profile) |
| except KeyError as e: |
| log.info("Get-tech-profile-failed", exception=e) |
| return None |
| |
| def _default_tech_profile(self): |
| # Default tech profile |
| upstream_gem_port_attribute_list = list() |
| downstream_gem_port_attribute_list = list() |
| for pbit in TechProfile.pbits: |
| upstream_gem_port_attribute_list.append( |
| GemPortAttribute(pbit_map=pbit, |
| discard_config=DiscardConfig())) |
| downstream_gem_port_attribute_list.append( |
| GemPortAttribute(pbit_map=pbit, |
| discard_config=DiscardConfig())) |
| |
| return TechProfile.DefaultTechProfile( |
| TechProfile.DEFAULT_TECH_PROFILE_NAME, |
| profile_type=self.resource_mgr.technology, |
| version=TechProfile.DEFAULT_VERSION, |
| num_gem_ports=TechProfile.DEFAULT_GEMPORTS_COUNT, |
| instance_control=InstanceControl(), |
| us_scheduler=Scheduler(direction=Direction.UPSTREAM.name), |
| ds_scheduler=Scheduler(direction=Direction.DOWNSTREAM.name), |
| upstream_gem_port_attribute_list=upstream_gem_port_attribute_list, |
| downstream_gem_port_attribute_list= |
| downstream_gem_port_attribute_list) |
| |
| @staticmethod |
| def _get_tech_profile(tech_profile): |
| # Tech profile fetched from kv store |
| instance_control = tech_profile[TechProfile.INSTANCE_CONTROL] |
| instance_control = InstanceControl( |
| onu=instance_control[TechProfile.ONU], |
| uni=instance_control[TechProfile.UNI], |
| max_gem_payload_size=instance_control[ |
| TechProfile.MAX_GEM_PAYLOAD_SIZE]) |
| |
| us_scheduler = tech_profile[TechProfile.US_SCHEDULER] |
| us_scheduler = Scheduler(direction=us_scheduler[TechProfile.DIRECTION], |
| additional_bw=us_scheduler[ |
| TechProfile.ADDITIONAL_BW], |
| priority=us_scheduler[TechProfile.PRIORITY], |
| weight=us_scheduler[TechProfile.WEIGHT], |
| q_sched_policy=us_scheduler[ |
| TechProfile.Q_SCHED_POLICY]) |
| ds_scheduler = tech_profile[TechProfile.DS_SCHEDULER] |
| ds_scheduler = Scheduler(direction=ds_scheduler[TechProfile.DIRECTION], |
| additional_bw=ds_scheduler[ |
| TechProfile.ADDITIONAL_BW], |
| priority=ds_scheduler[TechProfile.PRIORITY], |
| weight=ds_scheduler[TechProfile.WEIGHT], |
| q_sched_policy=ds_scheduler[ |
| TechProfile.Q_SCHED_POLICY]) |
| |
| upstream_gem_port_attribute_list = list() |
| downstream_gem_port_attribute_list = list() |
| us_gemport_attr_list = tech_profile[ |
| TechProfile.UPSTREAM_GEM_PORT_ATTRIBUTE_LIST] |
| for i in range(len(us_gemport_attr_list)): |
| upstream_gem_port_attribute_list.append( |
| GemPortAttribute(pbit_map=us_gemport_attr_list[i][TechProfile.PBIT_MAP], |
| discard_config=DiscardConfig( |
| max_threshold= |
| us_gemport_attr_list[i][TechProfile.DISCARD_CONFIG][ |
| TechProfile.MAX_THRESHOLD], |
| min_threshold= |
| us_gemport_attr_list[i][TechProfile.DISCARD_CONFIG][ |
| TechProfile.MIN_THRESHOLD], |
| max_probability= |
| us_gemport_attr_list[i][TechProfile.DISCARD_CONFIG][ |
| TechProfile.MAX_PROBABILITY]), |
| discard_policy=us_gemport_attr_list[i][ |
| TechProfile.DISCARD_POLICY], |
| priority_q=us_gemport_attr_list[i][ |
| TechProfile.PRIORITY_Q], |
| weight=us_gemport_attr_list[i][TechProfile.WEIGHT], |
| scheduling_policy=us_gemport_attr_list[i][ |
| TechProfile.SCHEDULING_POLICY], |
| max_q_size=us_gemport_attr_list[i][ |
| TechProfile.MAX_Q_SIZE], |
| aes_encryption=us_gemport_attr_list[i][ |
| TechProfile.AES_ENCRYPTION])) |
| |
| ds_gemport_attr_list = tech_profile[ |
| TechProfile.DOWNSTREAM_GEM_PORT_ATTRIBUTE_LIST] |
| for i in range(len(ds_gemport_attr_list)): |
| downstream_gem_port_attribute_list.append( |
| GemPortAttribute(pbit_map=ds_gemport_attr_list[i][TechProfile.PBIT_MAP], |
| discard_config=DiscardConfig( |
| max_threshold= |
| ds_gemport_attr_list[i][TechProfile.DISCARD_CONFIG][ |
| TechProfile.MAX_THRESHOLD], |
| min_threshold= |
| ds_gemport_attr_list[i][TechProfile.DISCARD_CONFIG][ |
| TechProfile.MIN_THRESHOLD], |
| max_probability= |
| ds_gemport_attr_list[i][TechProfile.DISCARD_CONFIG][ |
| TechProfile.MAX_PROBABILITY]), |
| discard_policy=ds_gemport_attr_list[i][ |
| TechProfile.DISCARD_POLICY], |
| priority_q=ds_gemport_attr_list[i][ |
| TechProfile.PRIORITY_Q], |
| weight=ds_gemport_attr_list[i][TechProfile.WEIGHT], |
| scheduling_policy=ds_gemport_attr_list[i][ |
| TechProfile.SCHEDULING_POLICY], |
| max_q_size=ds_gemport_attr_list[i][ |
| TechProfile.MAX_Q_SIZE], |
| aes_encryption=ds_gemport_attr_list[i][ |
| TechProfile.AES_ENCRYPTION])) |
| |
| return TechProfile.DefaultTechProfile( |
| tech_profile[TechProfile.NAME], |
| profile_type=tech_profile[TechProfile.PROFILE_TYPE], |
| version=tech_profile[TechProfile.VERSION], |
| num_gem_ports=tech_profile[TechProfile.NUM_GEM_PORTS], |
| instance_control=instance_control, |
| us_scheduler=us_scheduler, |
| ds_scheduler=ds_scheduler, |
| upstream_gem_port_attribute_list=upstream_gem_port_attribute_list, |
| downstream_gem_port_attribute_list= |
| downstream_gem_port_attribute_list) |
| |
| def _add_tech_profile_instance(self, path, tech_profile_instance): |
| """ |
| Add tech profile to kv store. |
| |
| :param path: path to add tech profile |
| :param tech_profile_instance: tech profile instance need to be added |
| """ |
| try: |
| self._kv_store[path] = str(tech_profile_instance) |
| log.debug("Add-tech-profile-instance-success", path=path, |
| tech_profile_instance=tech_profile_instance) |
| return True |
| except BaseException as e: |
| log.exception("Add-tech-profile-instance-failed", path=path, |
| tech_profile_instance=tech_profile_instance, |
| exception=e) |
| return False |
| |
| @staticmethod |
| def get_us_scheduler(tech_profile_instance): |
| # upstream scheduler |
| us_scheduler = openolt_pb2.Scheduler( |
| direction=TechProfile.get_parameter( |
| 'direction', tech_profile_instance.us_scheduler. |
| direction), |
| additional_bw=TechProfile.get_parameter( |
| 'additional_bw', tech_profile_instance. |
| us_scheduler.additional_bw), |
| priority=tech_profile_instance.us_scheduler.priority, |
| weight=tech_profile_instance.us_scheduler.weight, |
| sched_policy=TechProfile.get_parameter( |
| 'sched_policy', tech_profile_instance. |
| us_scheduler.q_sched_policy)) |
| |
| return us_scheduler |
| |
| @staticmethod |
| def get_ds_scheduler(tech_profile_instance): |
| ds_scheduler = openolt_pb2.Scheduler( |
| direction=TechProfile.get_parameter( |
| 'direction', tech_profile_instance.ds_scheduler. |
| direction), |
| additional_bw=TechProfile.get_parameter( |
| 'additional_bw', tech_profile_instance. |
| ds_scheduler.additional_bw), |
| priority=tech_profile_instance.ds_scheduler.priority, |
| weight=tech_profile_instance.ds_scheduler.weight, |
| sched_policy=TechProfile.get_parameter( |
| 'sched_policy', tech_profile_instance.ds_scheduler. |
| q_sched_policy)) |
| |
| return ds_scheduler |
| |
| @staticmethod |
| def get_tconts(tech_profile_instance, us_scheduler=None, ds_scheduler=None): |
| if us_scheduler is None: |
| us_scheduler = TechProfile.get_us_scheduler(tech_profile_instance) |
| if ds_scheduler is None: |
| ds_scheduler = TechProfile.get_ds_scheduler(tech_profile_instance) |
| |
| tconts = [openolt_pb2.Tcont(direction=TechProfile.get_parameter( |
| 'direction', |
| tech_profile_instance. |
| us_scheduler.direction), |
| alloc_id=tech_profile_instance. |
| us_scheduler.alloc_id, |
| scheduler=us_scheduler), |
| openolt_pb2.Tcont(direction=TechProfile.get_parameter( |
| 'direction', |
| tech_profile_instance. |
| ds_scheduler.direction), |
| alloc_id=tech_profile_instance. |
| ds_scheduler.alloc_id, |
| scheduler=ds_scheduler)] |
| |
| return tconts |
| |
| @staticmethod |
| def get_parameter(param_type, param_value): |
| parameter = None |
| try: |
| if param_type == 'direction': |
| for direction in openolt_pb2.Direction.keys(): |
| if param_value == direction: |
| parameter = direction |
| elif param_type == 'discard_policy': |
| for discard_policy in openolt_pb2.DiscardPolicy.keys(): |
| if param_value == discard_policy: |
| parameter = discard_policy |
| elif param_type == 'sched_policy': |
| for sched_policy in openolt_pb2.SchedulingPolicy.keys(): |
| if param_value == sched_policy: |
| parameter = sched_policy |
| elif param_type == 'additional_bw': |
| for bw_component in openolt_pb2.AdditionalBW.keys(): |
| if param_value == bw_component: |
| parameter = bw_component |
| except BaseException as e: |
| log.exception(exception=e) |
| return parameter |
| |
| |
| class TechProfileInstance(object): |
| def __init__(self, subscriber_identifier, tech_profile, resource_mgr, |
| intf_id, num_of_tconts=1): |
| if tech_profile is not None: |
| self.subscriber_identifier = subscriber_identifier |
| self.num_of_tconts = num_of_tconts |
| self.num_of_gem_ports = tech_profile.num_gem_ports |
| self.name = tech_profile.name |
| self.profile_type = tech_profile.profile_type |
| self.version = tech_profile.version |
| self.instance_control = tech_profile.instance_control |
| |
| # TODO: Fixed num_of_tconts to 1 per TP Instance. |
| # This may change in future |
| assert (num_of_tconts == 1) |
| # Get alloc id and gemport id using resource manager |
| alloc_id = resource_mgr.get_resource_id(intf_id, |
| 'ALLOC_ID', |
| num_of_tconts) |
| gem_ports = resource_mgr.get_resource_id(intf_id, |
| 'GEMPORT_ID', |
| self.num_of_gem_ports) |
| |
| gemport_list = list() |
| if isinstance(gem_ports, int): |
| gemport_list.append(gem_ports) |
| elif isinstance(gem_ports, list): |
| for gem in gem_ports: |
| gemport_list.append(gem) |
| else: |
| raise Exception("invalid-type") |
| |
| self.us_scheduler = TechProfileInstance.IScheduler( |
| alloc_id, tech_profile.us_scheduler) |
| self.ds_scheduler = TechProfileInstance.IScheduler( |
| alloc_id, tech_profile.ds_scheduler) |
| |
| self.upstream_gem_port_attribute_list = list() |
| self.downstream_gem_port_attribute_list = list() |
| for i in range(self.num_of_gem_ports): |
| self.upstream_gem_port_attribute_list.append( |
| TechProfileInstance.IGemPortAttribute( |
| gemport_list[i], |
| tech_profile.upstream_gem_port_attribute_list[ |
| i])) |
| self.downstream_gem_port_attribute_list.append( |
| TechProfileInstance.IGemPortAttribute( |
| gemport_list[i], |
| tech_profile.downstream_gem_port_attribute_list[ |
| i])) |
| |
| class IScheduler(Scheduler): |
| def __init__(self, alloc_id, scheduler): |
| super(TechProfileInstance.IScheduler, self).__init__( |
| scheduler.direction, scheduler.additional_bw, |
| scheduler.priority, |
| scheduler.weight, scheduler.q_sched_policy) |
| self.alloc_id = alloc_id |
| |
| class IGemPortAttribute(GemPortAttribute): |
| def __init__(self, gemport_id, gem_port_attribute): |
| super(TechProfileInstance.IGemPortAttribute, self).__init__( |
| gem_port_attribute.pbit_map, gem_port_attribute.discard_config, |
| gem_port_attribute.aes_encryption, |
| gem_port_attribute.scheduling_policy, |
| gem_port_attribute.priority_q, gem_port_attribute.weight, |
| gem_port_attribute.max_q_size, |
| gem_port_attribute.discard_policy) |
| self.gemport_id = gemport_id |
| |
| def to_json(self): |
| return json.dumps(self, default=lambda o: o.__dict__, |
| indent=4) |