Skip to content
Snippets Groups Projects
Commit 752bbe52 authored by delacal's avatar delacal
Browse files

Merge branch 'develop' into feat/l3-components

parents 45b6c0b4 cd94fed3
No related branches found
No related tags found
2 merge requests!142Release TeraFlowSDN 2.1,!93Updated L3 components + scalability
Hide whitespace changes
Inline Side-by-side
deploy_component.sh 0 → 100755
+ 186
− 0
View file @ 752bbe52
#!/bin/bash
# Copyright 2021-2023 H2020 TeraFlow (https://www.teraflow-h2020.eu/)
#
# 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.
########################################################################################################################
# Read deployment settings
########################################################################################################################
# If not already set, set the URL of your local Docker registry where the images will be uploaded to.
# Leave it blank if you do not want to use any Docker registry.
export TFS_REGISTRY_IMAGE=${TFS_REGISTRY_IMAGE:-""}
#export TFS_REGISTRY_IMAGE="http://my-container-registry.local/"
TFS_COMPONENTS=$1
# If not already set, set the tag you want to use for your images.
export TFS_IMAGE_TAG=${TFS_IMAGE_TAG:-"dev"}
# If not already set, set the name of the Kubernetes namespace to deploy to.
export TFS_K8S_NAMESPACE=${TFS_K8S_NAMESPACE:-"tfs"}
# If not already set, set additional manifest files to be applied after the deployment
export TFS_EXTRA_MANIFESTS=${TFS_EXTRA_MANIFESTS:-""}
# If not already set, set the neew Grafana admin password
export TFS_GRAFANA_PASSWORD=${TFS_GRAFANA_PASSWORD:-"admin123+"}
########################################################################################################################
# Automated steps start here
########################################################################################################################
# Constants
GITLAB_REPO_URL="registry.gitlab.com/teraflow-h2020/controller"
TMP_FOLDER="./tmp"
# Create a tmp folder for files modified during the deployment
TMP_MANIFESTS_FOLDER="$TMP_FOLDER/manifests"
TMP_LOGS_FOLDER="$TMP_FOLDER/logs"
echo "Deploying component and collecting environment variables..."
ENV_VARS_SCRIPT=tfs_runtime_env_vars.sh
for COMPONENT in $TFS_COMPONENTS; do
echo "Processing '$COMPONENT' component..."
IMAGE_NAME="$COMPONENT:$TFS_IMAGE_TAG"
IMAGE_URL=$(echo "$TFS_REGISTRY_IMAGE/$IMAGE_NAME" | sed 's,//,/,g' | sed 's,http:/,,g')
echo " Building Docker image..."
BUILD_LOG="$TMP_LOGS_FOLDER/build_${COMPONENT}.log"
if [ "$COMPONENT" == "automation" ] || [ "$COMPONENT" == "policy" ]; then
docker build -t "$IMAGE_NAME" -f ./src/"$COMPONENT"/Dockerfile ./src/"$COMPONENT"/ > "$BUILD_LOG"
elif [ "$COMPONENT" == "pathcomp" ]; then
BUILD_LOG="$TMP_LOGS_FOLDER/build_${COMPONENT}-frontend.log"
docker build -t "$COMPONENT-frontend:$TFS_IMAGE_TAG" -f ./src/"$COMPONENT"/frontend/Dockerfile . >> "$BUILD_LOG"
BUILD_LOG="$TMP_LOGS_FOLDER/build_${COMPONENT}-backend.log"
docker build -t "$COMPONENT-backend:$TFS_IMAGE_TAG" -f ./src/"$COMPONENT"/backend/Dockerfile . >> "$BUILD_LOG"
# next command is redundant, but helpful to keep cache updated between rebuilds
docker build -t "$COMPONENT-backend:$TFS_IMAGE_TAG-builder" --target builder -f ./src/"$COMPONENT"/backend/Dockerfile . >> "$BUILD_LOG"
else
docker build -t "$IMAGE_NAME" -f ./src/"$COMPONENT"/Dockerfile . > "$BUILD_LOG"
fi
if [ -n "$TFS_REGISTRY_IMAGE" ]; then
echo " Pushing Docker image to '$TFS_REGISTRY_IMAGE'..."
if [ "$COMPONENT" == "pathcomp" ]; then
TAG_LOG="$TMP_LOGS_FOLDER/tag_${COMPONENT}-frontend.log"
docker tag "$COMPONENT-frontend:$TFS_IMAGE_TAG" "$IMAGE_URL-frontend" > "$TAG_LOG"
TAG_LOG="$TMP_LOGS_FOLDER/tag_${COMPONENT}-backend.log"
docker tag "$COMPONENT-backend:$TFS_IMAGE_TAG" "$IMAGE_URL-backend" > "$TAG_LOG"
PUSH_LOG="$TMP_LOGS_FOLDER/push_${COMPONENT}-frontend.log"
docker push "$IMAGE_URL-frontend" > "$PUSH_LOG"
PUSH_LOG="$TMP_LOGS_FOLDER/push_${COMPONENT}-backend.log"
docker push "$IMAGE_URL-backend" > "$PUSH_LOG"
else
TAG_LOG="$TMP_LOGS_FOLDER/tag_${COMPONENT}.log"
docker tag "$IMAGE_NAME" "$IMAGE_URL" > "$TAG_LOG"
PUSH_LOG="$TMP_LOGS_FOLDER/push_${COMPONENT}.log"
docker push "$IMAGE_URL" > "$PUSH_LOG"
fi
fi
echo " Adapting '$COMPONENT' manifest file..."
MANIFEST="$TMP_MANIFESTS_FOLDER/${COMPONENT}service.yaml"
cp ./manifests/"${COMPONENT}"service.yaml "$MANIFEST"
if [ -n "$TFS_REGISTRY_IMAGE" ]; then
# Registry is set
if [ "$COMPONENT" == "pathcomp" ]; then
VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}-frontend:" "$MANIFEST" | cut -d ":" -f3)
sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT-frontend:${VERSION}#image: $IMAGE_URL-frontend#g" "$MANIFEST"
VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}-backend:" "$MANIFEST" | cut -d ":" -f3)
sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT-backend:${VERSION}#image: $IMAGE_URL-backend#g" "$MANIFEST"
sed -E -i "s#imagePullPolicy: .*#imagePullPolicy: Always#g" "$MANIFEST"
else
VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}:" "$MANIFEST" | cut -d ":" -f3)
sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT:${VERSION}#image: $IMAGE_URL#g" "$MANIFEST"
sed -E -i "s#imagePullPolicy: .*#imagePullPolicy: Always#g" "$MANIFEST"
fi
else
# Registry is not set
if [ "$COMPONENT" == "pathcomp" ]; then
VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}-frontend:" "$MANIFEST" | cut -d ":" -f3)
sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT-frontend:${VERSION}#image: $IMAGE_NAME-frontend#g" "$MANIFEST"
VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}-backend:" "$MANIFEST" | cut -d ":" -f3)
sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT-backend:${VERSION}#image: $IMAGE_NAME-backend#g" "$MANIFEST"
sed -E -i "s#imagePullPolicy: .*#imagePullPolicy: Never#g" "$MANIFEST"
else
VERSION=$(grep -i "${GITLAB_REPO_URL}/${COMPONENT}:" "$MANIFEST" | cut -d ":" -f3)
sed -E -i "s#image: $GITLAB_REPO_URL/$COMPONENT:${VERSION}#image: $IMAGE_NAME#g" "$MANIFEST"
sed -E -i "s#imagePullPolicy: .*#imagePullPolicy: Never#g" "$MANIFEST"
fi
fi
# TODO: harmonize names of the monitoring component
echo " Deploying '$COMPONENT' component to Kubernetes..."
DEPLOY_LOG="$TMP_LOGS_FOLDER/deploy_${COMPONENT}.log"
kubectl --namespace $TFS_K8S_NAMESPACE delete -f "$MANIFEST" > "$DEPLOY_LOG"
kubectl --namespace $TFS_K8S_NAMESPACE apply -f "$MANIFEST" > "$DEPLOY_LOG"
COMPONENT_OBJNAME=$(echo "${COMPONENT}" | sed "s/\_/-/")
kubectl --namespace $TFS_K8S_NAMESPACE scale deployment --replicas=0 ${COMPONENT_OBJNAME}service >> "$DEPLOY_LOG"
kubectl --namespace $TFS_K8S_NAMESPACE scale deployment --replicas=1 ${COMPONENT_OBJNAME}service >> "$DEPLOY_LOG"
echo " Collecting env-vars for '$COMPONENT' component..."
SERVICE_DATA=$(kubectl get service ${COMPONENT}service --namespace $TFS_K8S_NAMESPACE -o json)
if [ -z "${SERVICE_DATA}" ]; then continue; fi
# Env vars for service's host address
SERVICE_HOST=$(echo ${SERVICE_DATA} | jq -r '.spec.clusterIP')
if [ -z "${SERVICE_HOST}" ]; then continue; fi
# TODO: remove previous value from file
ENVVAR_HOST=$(echo "${COMPONENT}service_SERVICE_HOST" | tr '[:lower:]' '[:upper:]')
echo "export ${ENVVAR_HOST}=${SERVICE_HOST}" >> $ENV_VARS_SCRIPT
# Env vars for service's 'grpc' port (if any)
SERVICE_PORT_GRPC=$(echo ${SERVICE_DATA} | jq -r '.spec.ports[] | select(.name=="grpc") | .port')
if [ -n "${SERVICE_PORT_GRPC}" ]; then
ENVVAR_PORT_GRPC=$(echo "${COMPONENT}service_SERVICE_PORT_GRPC" | tr '[:lower:]' '[:upper:]')
echo "export ${ENVVAR_PORT_GRPC}=${SERVICE_PORT_GRPC}" >> $ENV_VARS_SCRIPT
fi
# Env vars for service's 'http' port (if any)
SERVICE_PORT_HTTP=$(echo ${SERVICE_DATA} | jq -r '.spec.ports[] | select(.name=="http") | .port')
if [ -n "${SERVICE_PORT_HTTP}" ]; then
ENVVAR_PORT_HTTP=$(echo "${COMPONENT}service_SERVICE_PORT_HTTP" | tr '[:lower:]' '[:upper:]')
echo "export ${ENVVAR_PORT_HTTP}=${SERVICE_PORT_HTTP}" >> $ENV_VARS_SCRIPT
fi
printf "\n"
done
# By now, leave this control here. Some component dependencies are not well handled
for COMPONENT in $TFS_COMPONENTS; do
echo "Waiting for '$COMPONENT' component..."
kubectl wait --namespace $TFS_K8S_NAMESPACE \
--for='condition=available' --timeout=300s deployment/${COMPONENT}service
printf "\n"
done
./show_deploy.sh
echo "Done!"
src/compute/tests/mock_osm/WimconnectorIETFL2VPN.py
+ 1
− 1
View file @ 752bbe52
......@@ -371,7 +371,7 @@ class WimconnectorIETFL2VPN(SdnConnectorBase):
self.delete_connectivity_service(vpn_service["vpn-id"])
raise SdnConnectorError(
"Request no accepted",
"Request not accepted",
http_code=response_endpoint_site_network_access_creation.status_code,
)
except requests.exceptions.ConnectionError:
......
src/service/service/service_handlers/l3nm_emulated/ConfigRules.py 0 → 100644
+ 137
− 0
View file @ 752bbe52
# Copyright 2021-2023 H2020 TeraFlow (https://www.teraflow-h2020.eu/)
#
# 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.
from typing import Dict, List
from common.tools.object_factory.ConfigRule import json_config_rule_delete, json_config_rule_set
from service.service.service_handler_api.AnyTreeTools import TreeNode
def setup_config_rules(
service_uuid : str, connection_uuid : str, device_uuid : str, endpoint_uuid : str,
service_settings : TreeNode, endpoint_settings : TreeNode
) -> List[Dict]:
json_settings : Dict = {} if service_settings is None else service_settings.value
json_endpoint_settings : Dict = {} if endpoint_settings is None else endpoint_settings.value
service_short_uuid = service_uuid.split('-')[-1]
network_instance_name = '{:s}-NetInst'.format(service_short_uuid)
network_interface_desc = '{:s}-NetIf'.format(service_uuid)
network_subinterface_desc = '{:s}-NetSubIf'.format(service_uuid)
mtu = json_settings.get('mtu', 1450 ) # 1512
bgp_as = json_settings.get('bgp_as', 0 ) # 65000
bgp_route_target = json_settings.get('bgp_route_target', '0:0') # 65000:333
#router_id = json_endpoint_settings.get('router_id', '0.0.0.0') # '10.95.0.10'
route_distinguisher = json_endpoint_settings.get('route_distinguisher', '0:0' ) # '60001:801'
sub_interface_index = json_endpoint_settings.get('sub_interface_index', 0 ) # 1
vlan_id = json_endpoint_settings.get('vlan_id', 1 ) # 400
address_ip = json_endpoint_settings.get('address_ip', '0.0.0.0') # '2.2.2.1'
address_prefix = json_endpoint_settings.get('address_prefix', 24 ) # 30
if_subif_name = '{:s}.{:d}'.format(endpoint_uuid, vlan_id)
json_config_rules = [
json_config_rule_set(
'/network_instance[{:s}]'.format(network_instance_name), {
'name': network_instance_name, 'description': network_interface_desc, 'type': 'L3VRF',
'route_distinguisher': route_distinguisher,
#'router_id': router_id, 'address_families': address_families,
}),
json_config_rule_set(
'/interface[{:s}]'.format(endpoint_uuid), {
'name': endpoint_uuid, 'description': network_interface_desc, 'mtu': mtu,
}),
json_config_rule_set(
'/interface[{:s}]/subinterface[{:d}]'.format(endpoint_uuid, sub_interface_index), {
'name': endpoint_uuid, 'index': sub_interface_index,
'description': network_subinterface_desc, 'vlan_id': vlan_id,
'address_ip': address_ip, 'address_prefix': address_prefix,
}),
json_config_rule_set(
'/network_instance[{:s}]/interface[{:s}]'.format(network_instance_name, if_subif_name), {
'name': network_instance_name, 'id': if_subif_name, 'interface': endpoint_uuid,
'subinterface': sub_interface_index,
}),
json_config_rule_set(
'/network_instance[{:s}]/protocols[BGP]'.format(network_instance_name), {
'name': network_instance_name, 'identifier': 'BGP', 'protocol_name': 'BGP', 'as': bgp_as,
}),
json_config_rule_set(
'/network_instance[{:s}]/table_connections[STATIC][BGP][IPV4]'.format(network_instance_name), {
'name': network_instance_name, 'src_protocol': 'STATIC', 'dst_protocol': 'BGP',
'address_family': 'IPV4', #'default_import_policy': 'REJECT_ROUTE',
}),
json_config_rule_set(
'/network_instance[{:s}]/table_connections[DIRECTLY_CONNECTED][BGP][IPV4]'.format(
network_instance_name), {
'name': network_instance_name, 'src_protocol': 'DIRECTLY_CONNECTED', 'dst_protocol': 'BGP',
'address_family': 'IPV4', #'default_import_policy': 'REJECT_ROUTE',
}),
json_config_rule_set(
'/routing_policy/bgp_defined_set[{:s}_rt_import]'.format(network_instance_name), {
'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/bgp_defined_set[{:s}_rt_import][route-target:{:s}]'.format(
network_instance_name, bgp_route_target), {
'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
'ext_community_member' : 'route-target:{:s}'.format(bgp_route_target),
}),
json_config_rule_set(
'/routing_policy/policy_definition[{:s}_import]'.format(network_instance_name), {
'policy_name': '{:s}_import'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/policy_definition[{:s}_import]/statement[{:s}]'.format(
network_instance_name, '3'), {
'policy_name': '{:s}_import'.format(network_instance_name), 'statement_name': '3',
'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
'match_set_options': 'ANY', 'policy_result': 'ACCEPT_ROUTE',
}),
json_config_rule_set(
# pylint: disable=duplicate-string-formatting-argument
'/network_instance[{:s}]/inter_instance_policies[{:s}_import]'.format(
network_instance_name, network_instance_name), {
'name': network_instance_name, 'import_policy': '{:s}_import'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/bgp_defined_set[{:s}_rt_export]'.format(network_instance_name), {
'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/bgp_defined_set[{:s}_rt_export][route-target:{:s}]'.format(
network_instance_name, bgp_route_target), {
'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
'ext_community_member' : 'route-target:{:s}'.format(bgp_route_target),
}),
json_config_rule_set(
'/routing_policy/policy_definition[{:s}_export]'.format(network_instance_name), {
'policy_name': '{:s}_export'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/policy_definition[{:s}_export]/statement[{:s}]'.format(
network_instance_name, '3'), {
'policy_name': '{:s}_export'.format(network_instance_name), 'statement_name': '3',
'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
'match_set_options': 'ANY', 'policy_result': 'ACCEPT_ROUTE',
}),
json_config_rule_set(
# pylint: disable=duplicate-string-formatting-argument
'/network_instance[{:s}]/inter_instance_policies[{:s}_export]'.format(
network_instance_name, network_instance_name), {
'name': network_instance_name, 'export_policy': '{:s}_export'.format(network_instance_name),
}),
]
return json_config_rules
\ No newline at end of file
src/service/service/service_handlers/l3nm_emulated/L3NMEmulatedServiceHandler.py
+ 158
− 136
View file @ 752bbe52
......@@ -14,65 +14,73 @@
import anytree, json, logging
from typing import Any, Dict, List, Optional, Tuple, Union
from common.orm.Database import Database
from common.orm.HighLevel import get_object
from common.orm.backend.Tools import key_to_str
from common.proto.context_pb2 import Device
from common.proto.context_pb2 import ConfigActionEnum, ConfigRule, Device, DeviceId, Service
from common.tools.object_factory.Device import json_device_id
from common.tools.object_factory.ConfigRule import json_config_rule_delete, json_config_rule_set
from common.type_checkers.Checkers import chk_length, chk_type
from context.client.ContextClient import ContextClient
from device.client.DeviceClient import DeviceClient
from service.service.database.ConfigModel import ORM_ConfigActionEnum, get_config_rules
from service.service.database.ConfigModel import ORM_ConfigActionEnum
from service.service.database.ContextModel import ContextModel
from service.service.database.DeviceModel import DeviceModel
from service.service.database.ServiceModel import ServiceModel
from service.service.task_scheduler.TaskExecutor import TaskExecutor
from service.service.service_handler_api._ServiceHandler import _ServiceHandler
from service.service.service_handler_api.AnyTreeTools import TreeNode, delete_subnode, get_subnode, set_subnode_value
from .ConfigRules import setup_config_rules
LOGGER = logging.getLogger(__name__)
class L3NMEmulatedServiceHandler(_ServiceHandler):
def __init__( # pylint: disable=super-init-not-called
self, db_service : ServiceModel, database : Database, context_client : ContextClient,
device_client : DeviceClient, **settings
self, service : Service, task_executor : TaskExecutor, **settings
) -> None:
self.__db_service = db_service
self.__database = database
self.__context_client = context_client # pylint: disable=unused-private-member
self.__device_client = device_client
self.__db_context : ContextModel = get_object(self.__database, ContextModel, self.__db_service.context_fk)
str_service_key = key_to_str([self.__db_context.context_uuid, self.__db_service.service_uuid])
db_config = get_config_rules(self.__database, str_service_key, 'running')
self.__service = service
self.__task_executor = task_executor # pylint: disable=unused-private-member
self.__resolver = anytree.Resolver(pathattr='name')
self.__config = TreeNode('.')
for action, resource_key, resource_value in db_config:
if action == ORM_ConfigActionEnum.SET:
for config_rule in service.service_config.config_rules:
action = config_rule.action
if config_rule.WhichOneof('config_rule') != 'custom': continue
resource_key = config_rule.custom.resource_key
resource_value = config_rule.custom.resource_value
if action == ConfigActionEnum.CONFIGACTION_SET:
try:
resource_value = json.loads(resource_value)
except: # pylint: disable=bare-except
pass
set_subnode_value(self.__resolver, self.__config, resource_key, resource_value)
elif action == ORM_ConfigActionEnum.DELETE:
elif action == ConfigActionEnum.CONFIGACTION_DELETE:
delete_subnode(self.__resolver, self.__config, resource_key)
def SetEndpoint(self, endpoints : List[Tuple[str, str, Optional[str]]]) -> List[Union[bool, Exception]]:
# if config_rule.action == ORM_ConfigActionEnum.SET:
# try:
# resource_value = json.loads(config_rule.resource_value)
# except: # pylint: disable=bare-except
# pass
# set_subnode_value(self.__resolver, self.__config, config_rule.resource_key, config_rule.resource_value)
# elif config_rule.action == ORM_ConfigActionEnum.DELETE:
# delete_subnode(self.__resolver, self.__config, config_rule.resource_key)
def SetEndpoint(
self, endpoints : List[Tuple[str, str, Optional[str]]], connection_uuid : Optional[str] = None
) -> List[Union[bool, Exception]]:
chk_type('endpoints', endpoints, list)
if len(endpoints) == 0: return []
service_uuid = self.__db_service.service_uuid
service_short_uuid = service_uuid.split('-')[-1]
network_instance_name = '{:s}-NetInst'.format(service_short_uuid)
network_interface_desc = '{:s}-NetIf'.format(service_uuid)
network_subinterface_desc = '{:s}-NetSubIf'.format(service_uuid)
service_uuid = self.__service.service_id.service_uuid.uuid
# service_short_uuid = service_uuid.split('-')[-1]
# network_instance_name = '{:s}-NetInst'.format(service_short_uuid)
# network_interface_desc = '{:s}-NetIf'.format(service_uuid)
# network_subinterface_desc = '{:s}-NetSubIf'.format(service_uuid)
settings : TreeNode = get_subnode(self.__resolver, self.__config, '/settings', None)
if settings is None: raise Exception('Unable to retrieve service settings')
json_settings : Dict = settings.value
mtu = json_settings.get('mtu', 1450 ) # 1512
# mtu = json_settings.get('mtu', 1450 ) # 1512
#address_families = json_settings.get('address_families', [] ) # ['IPV4']
bgp_as = json_settings.get('bgp_as', 0 ) # 65000
bgp_route_target = json_settings.get('bgp_route_target', '0:0') # 65000:333
# bgp_as = json_settings.get('bgp_as', 0 ) # 65000
# bgp_route_target = json_settings.get('bgp_route_target', '0:0') # 65000:333
results = []
for endpoint in endpoints:
......@@ -85,117 +93,131 @@ class L3NMEmulatedServiceHandler(_ServiceHandler):
device_uuid, endpoint_uuid, _ = endpoint # ignore topology_uuid by now
endpoint_settings_uri = '/device[{:s}]/endpoint[{:s}]/settings'.format(device_uuid, endpoint_uuid)
# `endpoint_settings` is None
endpoint_settings : TreeNode = get_subnode(self.__resolver, self.__config, endpoint_settings_uri, None)
if endpoint_settings is None:
raise Exception('Unable to retrieve service settings for endpoint({:s})'.format(
str(endpoint_settings_uri)))
json_endpoint_settings : Dict = endpoint_settings.value
#router_id = json_endpoint_settings.get('router_id', '0.0.0.0') # '10.95.0.10'
route_distinguisher = json_endpoint_settings.get('route_distinguisher', '0:0' ) # '60001:801'
sub_interface_index = json_endpoint_settings.get('sub_interface_index', 0 ) # 1
vlan_id = json_endpoint_settings.get('vlan_id', 1 ) # 400
address_ip = json_endpoint_settings.get('address_ip', '0.0.0.0') # '2.2.2.1'
address_prefix = json_endpoint_settings.get('address_prefix', 24 ) # 30
if_subif_name = '{:s}.{:d}'.format(endpoint_uuid, vlan_id)
db_device : DeviceModel = get_object(self.__database, DeviceModel, device_uuid, raise_if_not_found=True)
json_device = db_device.dump(include_config_rules=False, include_drivers=True, include_endpoints=True)
json_device_config : Dict = json_device.setdefault('device_config', {})
json_device_config_rules : List = json_device_config.setdefault('config_rules', [])
json_device_config_rules.extend([
json_config_rule_set(
'/network_instance[{:s}]'.format(network_instance_name), {
'name': network_instance_name, 'description': network_interface_desc, 'type': 'L3VRF',
'route_distinguisher': route_distinguisher,
#'router_id': router_id, 'address_families': address_families,
}),
json_config_rule_set(
'/interface[{:s}]'.format(endpoint_uuid), {
'name': endpoint_uuid, 'description': network_interface_desc, 'mtu': mtu,
}),
json_config_rule_set(
'/interface[{:s}]/subinterface[{:d}]'.format(endpoint_uuid, sub_interface_index), {
'name': endpoint_uuid, 'index': sub_interface_index,
'description': network_subinterface_desc, 'vlan_id': vlan_id,
'address_ip': address_ip, 'address_prefix': address_prefix,
}),
json_config_rule_set(
'/network_instance[{:s}]/interface[{:s}]'.format(network_instance_name, if_subif_name), {
'name': network_instance_name, 'id': if_subif_name, 'interface': endpoint_uuid,
'subinterface': sub_interface_index,
}),
json_config_rule_set(
'/network_instance[{:s}]/protocols[BGP]'.format(network_instance_name), {
'name': network_instance_name, 'identifier': 'BGP', 'protocol_name': 'BGP', 'as': bgp_as,
}),
json_config_rule_set(
'/network_instance[{:s}]/table_connections[STATIC][BGP][IPV4]'.format(network_instance_name), {
'name': network_instance_name, 'src_protocol': 'STATIC', 'dst_protocol': 'BGP',
'address_family': 'IPV4', #'default_import_policy': 'REJECT_ROUTE',
}),
json_config_rule_set(
'/network_instance[{:s}]/table_connections[DIRECTLY_CONNECTED][BGP][IPV4]'.format(
network_instance_name), {
'name': network_instance_name, 'src_protocol': 'DIRECTLY_CONNECTED', 'dst_protocol': 'BGP',
'address_family': 'IPV4', #'default_import_policy': 'REJECT_ROUTE',
}),
json_config_rule_set(
'/routing_policy/bgp_defined_set[{:s}_rt_import]'.format(network_instance_name), {
'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/bgp_defined_set[{:s}_rt_import][route-target:{:s}]'.format(
network_instance_name, bgp_route_target), {
'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
'ext_community_member' : 'route-target:{:s}'.format(bgp_route_target),
}),
json_config_rule_set(
'/routing_policy/policy_definition[{:s}_import]'.format(network_instance_name), {
'policy_name': '{:s}_import'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/policy_definition[{:s}_import]/statement[{:s}]'.format(
network_instance_name, '3'), {
'policy_name': '{:s}_import'.format(network_instance_name), 'statement_name': '3',
'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
'match_set_options': 'ANY', 'policy_result': 'ACCEPT_ROUTE',
}),
json_config_rule_set(
# pylint: disable=duplicate-string-formatting-argument
'/network_instance[{:s}]/inter_instance_policies[{:s}_import]'.format(
network_instance_name, network_instance_name), {
'name': network_instance_name, 'import_policy': '{:s}_import'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/bgp_defined_set[{:s}_rt_export]'.format(network_instance_name), {
'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/bgp_defined_set[{:s}_rt_export][route-target:{:s}]'.format(
network_instance_name, bgp_route_target), {
'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
'ext_community_member' : 'route-target:{:s}'.format(bgp_route_target),
}),
json_config_rule_set(
'/routing_policy/policy_definition[{:s}_export]'.format(network_instance_name), {
'policy_name': '{:s}_export'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/policy_definition[{:s}_export]/statement[{:s}]'.format(
network_instance_name, '3'), {
'policy_name': '{:s}_export'.format(network_instance_name), 'statement_name': '3',
'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
'match_set_options': 'ANY', 'policy_result': 'ACCEPT_ROUTE',
}),
json_config_rule_set(
# pylint: disable=duplicate-string-formatting-argument
'/network_instance[{:s}]/inter_instance_policies[{:s}_export]'.format(
network_instance_name, network_instance_name), {
'name': network_instance_name, 'export_policy': '{:s}_export'.format(network_instance_name),
}),
])
self.__device_client.ConfigureDevice(Device(**json_device))
# new code starts here
json_config_rules = setup_config_rules(
service_uuid, connection_uuid, device_uuid, endpoint_uuid, settings, endpoint_settings)
device = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
for json_config_rule in json_config_rules:
device.device_config.config_rules.append(ConfigRule(**json_config_rule))
self.__task_executor.configure_device(device)
results.append(True)
# new code stops here
# json_endpoint_settings : Dict = endpoint_settings.value
# #router_id = json_endpoint_settings.get('router_id', '0.0.0.0') # '10.95.0.10'
# route_distinguisher = json_endpoint_settings.get('route_distinguisher', '0:0' ) # '60001:801'
# sub_interface_index = json_endpoint_settings.get('sub_interface_index', 0 ) # 1
# vlan_id = json_endpoint_settings.get('vlan_id', 1 ) # 400
# address_ip = json_endpoint_settings.get('address_ip', '0.0.0.0') # '2.2.2.1'
# address_prefix = json_endpoint_settings.get('address_prefix', 24 ) # 30
# if_subif_name = '{:s}.{:d}'.format(endpoint_uuid, vlan_id)
# db_device : DeviceModel = get_object(self.__database, DeviceModel, device_uuid, raise_if_not_found=True)
# device = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
# json_device = db_device.dump(include_config_rules=False, include_drivers=True, include_endpoints=True)
# json_device_config : Dict = json_device.setdefault('device_config', {})
# json_device_config_rules : List = json_device_config.setdefault('config_rules', [])
# json_device_config_rules.extend([
# json_config_rule_set(
# '/network_instance[{:s}]'.format(network_instance_name), {
# 'name': network_instance_name, 'description': network_interface_desc, 'type': 'L3VRF',
# 'route_distinguisher': route_distinguisher,
# #'router_id': router_id, 'address_families': address_families,
# }),
# json_config_rule_set(
# '/interface[{:s}]'.format(endpoint_uuid), {
# 'name': endpoint_uuid, 'description': network_interface_desc, 'mtu': mtu,
# }),
# json_config_rule_set(
# '/interface[{:s}]/subinterface[{:d}]'.format(endpoint_uuid, sub_interface_index), {
# 'name': endpoint_uuid, 'index': sub_interface_index,
# 'description': network_subinterface_desc, 'vlan_id': vlan_id,
# 'address_ip': address_ip, 'address_prefix': address_prefix,
# }),
# json_config_rule_set(
# '/network_instance[{:s}]/interface[{:s}]'.format(network_instance_name, if_subif_name), {
# 'name': network_instance_name, 'id': if_subif_name, 'interface': endpoint_uuid,
# 'subinterface': sub_interface_index,
# }),
# json_config_rule_set(
# '/network_instance[{:s}]/protocols[BGP]'.format(network_instance_name), {
# 'name': network_instance_name, 'identifier': 'BGP', 'protocol_name': 'BGP', 'as': bgp_as,
# }),
# json_config_rule_set(
# '/network_instance[{:s}]/table_connections[STATIC][BGP][IPV4]'.format(network_instance_name), {
# 'name': network_instance_name, 'src_protocol': 'STATIC', 'dst_protocol': 'BGP',
# 'address_family': 'IPV4', #'default_import_policy': 'REJECT_ROUTE',
# }),
# json_config_rule_set(
# '/network_instance[{:s}]/table_connections[DIRECTLY_CONNECTED][BGP][IPV4]'.format(
# network_instance_name), {
# 'name': network_instance_name, 'src_protocol': 'DIRECTLY_CONNECTED', 'dst_protocol': 'BGP',
# 'address_family': 'IPV4', #'default_import_policy': 'REJECT_ROUTE',
# }),
# json_config_rule_set(
# '/routing_policy/bgp_defined_set[{:s}_rt_import]'.format(network_instance_name), {
# 'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
# }),
# json_config_rule_set(
# '/routing_policy/bgp_defined_set[{:s}_rt_import][route-target:{:s}]'.format(
# network_instance_name, bgp_route_target), {
# 'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
# 'ext_community_member' : 'route-target:{:s}'.format(bgp_route_target),
# }),
# json_config_rule_set(
# '/routing_policy/policy_definition[{:s}_import]'.format(network_instance_name), {
# 'policy_name': '{:s}_import'.format(network_instance_name),
# }),
# json_config_rule_set(
# '/routing_policy/policy_definition[{:s}_import]/statement[{:s}]'.format(
# network_instance_name, '3'), {
# 'policy_name': '{:s}_import'.format(network_instance_name), 'statement_name': '3',
# 'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
# 'match_set_options': 'ANY', 'policy_result': 'ACCEPT_ROUTE',
# }),
# json_config_rule_set(
# # pylint: disable=duplicate-string-formatting-argument
# '/network_instance[{:s}]/inter_instance_policies[{:s}_import]'.format(
# network_instance_name, network_instance_name), {
# 'name': network_instance_name, 'import_policy': '{:s}_import'.format(network_instance_name),
# }),
# json_config_rule_set(
# '/routing_policy/bgp_defined_set[{:s}_rt_export]'.format(network_instance_name), {
# 'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
# }),
# json_config_rule_set(
# '/routing_policy/bgp_defined_set[{:s}_rt_export][route-target:{:s}]'.format(
# network_instance_name, bgp_route_target), {
# 'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
# 'ext_community_member' : 'route-target:{:s}'.format(bgp_route_target),
# }),
# json_config_rule_set(
# '/routing_policy/policy_definition[{:s}_export]'.format(network_instance_name), {
# 'policy_name': '{:s}_export'.format(network_instance_name),
# }),
# json_config_rule_set(
# '/routing_policy/policy_definition[{:s}_export]/statement[{:s}]'.format(
# network_instance_name, '3'), {
# 'policy_name': '{:s}_export'.format(network_instance_name), 'statement_name': '3',
# 'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
# 'match_set_options': 'ANY', 'policy_result': 'ACCEPT_ROUTE',
# }),
# json_config_rule_set(
# # pylint: disable=duplicate-string-formatting-argument
# '/network_instance[{:s}]/inter_instance_policies[{:s}_export]'.format(
# network_instance_name, network_instance_name), {
# 'name': network_instance_name, 'export_policy': '{:s}_export'.format(network_instance_name),
# }),
# ])
# self.__device_client.ConfigureDevice(Device(**json_device))
# results.append(True)
except Exception as e: # pylint: disable=broad-except
LOGGER.exception('Unable to SetEndpoint({:s})'.format(str(endpoint)))
results.append(e)
......@@ -206,7 +228,7 @@ class L3NMEmulatedServiceHandler(_ServiceHandler):
chk_type('endpoints', endpoints, list)
if len(endpoints) == 0: return []
service_uuid = self.__db_service.service_uuid
service_uuid = self.__service.service_id.service_uuid.uuid
service_short_uuid = service_uuid.split('-')[-1]
network_instance_name = '{:s}-NetInst'.format(service_short_uuid)
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment