Several changes: (f7b5ea1a) · Commits · TFS / controller

manifests/.gitlab-ci.yml

+0 −1

Original line number	Diff line number	Diff line
		@@ -6,5 +6,4 @@ dependencies all:
		- kubectl version
		- kubectl get all
		- kubectl apply -f "manifests/prometheus.yaml"
		- kubectl apply -f "manifests/redis.yaml"
		- kubectl get all

manifests/contextservice.yaml

+14 −0

Original line number	Diff line number	Diff line
		@@ -6,6 +6,7 @@ spec:
		selector:
		matchLabels:
		app: contextservice
		replicas: 1
		template:
		metadata:
		labels:
		@@ -13,6 +14,17 @@ spec:
		spec:
		terminationGracePeriodSeconds: 5
		containers:
		- name: redis
		image: redis:6.2
		ports:
		- containerPort: 6379
		resources:
		requests:
		cpu: 250m
		memory: 512Mi
		limits:
		cpu: 700m
		memory: 1024Mi
		- name: server
		image: registry.gitlab.com/teraflow-h2020/controller/context:latest
		imagePullPolicy: Always
		@@ -26,6 +38,8 @@ spec:
		value: "0"
		- name: LOG_LEVEL
		value: "DEBUG"
		- name: POPULATE_FAKE_DATA
		value: "true"
		readinessProbe:
		exec:
		command: ["/bin/grpc_health_probe", "-addr=:1010"]

manifests/redis.yaml

deleted100644 → 0

+0 −54

Original line number	Diff line number	Diff line
		---
		apiVersion: apps/v1
		kind: Deployment
		metadata:
		name: redis
		spec:
		selector:
		matchLabels:
		app: redis
		replicas: 1
		template:
		metadata:
		labels:
		app: redis
		version: v1
		spec:
		containers:
		- name: redis
		image: redis:6.2
		ports:
		- containerPort: 6379
		---
		apiVersion: v1
		kind: Service
		metadata:
		name: redis
		labels:
		app: redis
		spec:
		type: ClusterIP
		selector:
		app: redis
		ports:
		- name: redis
		protocol: TCP
		port: 6379
		targetPort: 6379
		---
		apiVersion: v1
		kind: Service
		metadata:
		name: redis-public
		labels:
		app: redis
		spec:
		type: NodePort
		selector:
		app: redis
		ports:
		- name: redis
		protocol: TCP
		port: 6379
		targetPort: 6379
		---

run_local_tests.sh

+2 −4

Original line number	Diff line number	Diff line
		@@ -22,10 +22,8 @@ coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose \
		#coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose \
		# centralizedcybersecurity/tests/test_unitary.py

		coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose --maxfail=1\
		context/tests/test_unitary_fast_hasher.py \
		context/tests/test_unitary_grpc.py \
		#context/tests/test_unitary_rest.py
		coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose \
		context/tests/test_unitary.py

		#coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose \
		# device/tests/test_unitary_driverapi.py \

src/common/type_checkers/Assertions.py

+250 −139

Original line number	Diff line number	Diff line
		def validate_empty(message):
		assert type(message) is dict
		assert len(message.keys()) == 0
		# ----- Enumerations ---------------------------------------------------------------------------------------------------

		def validate_config_action_enum(message):
		assert isinstance(message, str)
		assert message in [
		'CONFIGACTION_UNDEFINED',
		'CONFIGACTION_SET',
		'CONFIGACTION_DELETE',
		]

		def validate_device_driver_enum(message):
		assert isinstance(message, str)
		assert message in [
		'DEVICEDRIVER_UNDEFINED',
		'DEVICEDRIVER_OPENCONFIG',
		'DEVICEDRIVER_TRANSPORT_API',
		'DEVICEDRIVER_P4',
		'DEVICEDRIVER_IETF_NETWORK_TOPOLOGY',
		'DEVICEDRIVER_ONF_TR_352',
		]

		def validate_device_operational_status_enum(message):
		assert isinstance(message, str)
		assert message in [
		'DEVICEOPERATIONALSTATUS_UNDEFINED',
		'DEVICEOPERATIONALSTATUS_DISABLED',
		'DEVICEOPERATIONALSTATUS_ENABLED'
		]

		def validate_service_type_enum(message):
		assert isinstance(message, str)
		assert message in [
		'SERVICETYPE_UNKNOWN',
		'SERVICETYPE_L3NM',
		'SERVICETYPE_L2NM',
		'SERVICETYPE_TAPI_CONNECTIVITY_SERVICE',
		]

		def validate_service_state_enum(message):
		assert isinstance(message, str)
		assert message in [
		'SERVICESTATUS_UNDEFINED',
		'SERVICESTATUS_PLANNED',
		'SERVICESTATUS_ACTIVE',
		'SERVICESTATUS_PENDING_REMOVAL',
		]


		# ----- Common ---------------------------------------------------------------------------------------------------------
		def validate_uuid(message, allow_empty=False):
		assert type(message) is dict
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'uuid' in message
		assert type(message['uuid']) is str
		assert isinstance(message['uuid'], str)
		if allow_empty: return
		assert len(message['uuid']) > 1

		def validate_config_rule(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 3
		assert 'action' in message
		validate_config_action_enum(message['action'])
		assert 'resource_key' in message
		assert isinstance(message['resource_key'], str)
		assert 'resource_value' in message
		assert isinstance(message['resource_value'], str)

		def validate_config_rules(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'config_rules' in message
		for config_rule in message['config_rules']: validate_config_rule(config_rule)

		def validate_constraint(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 2
		assert 'constraint_type' in message
		assert isinstance(message['constraint_type'], str)
		assert 'constraint_value' in message
		assert isinstance(message['constraint_value'], str)


		# ----- Identifiers ----------------------------------------------------------------------------------------------------

		def validate_context_id(message):
		assert type(message) is dict
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'contextUuid' in message
		validate_uuid(message['contextUuid'])
		assert 'context_uuid' in message
		validate_uuid(message['context_uuid'])

		def validate_service_id(message, context_uuid=None):
		assert isinstance(message, dict)
		assert len(message.keys()) == 2
		assert 'context_id' in message
		validate_context_id(message['context_id'])
		if context_uuid is not None: assert message['context_id']['context_uuid']['uuid'] == context_uuid
		assert 'service_uuid' in message
		validate_uuid(message['service_uuid'])

		def validate_topology_id(message, context_uuid=None):
		assert isinstance(message, dict)
		assert len(message.keys()) == 2
		assert 'context_id' in message
		validate_context_id(message['context_id'])
		if context_uuid is not None: assert message['context_id']['context_uuid']['uuid'] == context_uuid
		assert 'topology_uuid' in message
		validate_uuid(message['topology_uuid'])

		def validate_device_id(message):
		assert type(message) is dict
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'device_id' in message
		validate_uuid(message['device_id'])
		assert 'device_uuid' in message
		validate_uuid(message['device_uuid'])

		def validate_link_id(message):
		assert type(message) is dict
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'link_id' in message
		validate_uuid(message['link_id'])
		assert 'link_uuid' in message
		validate_uuid(message['link_uuid'])

		def validate_endpoint_id(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 3
		assert 'topology_id' in message
		validate_topology_id(message['topology_id'])
		assert 'device_id' in message
		validate_device_id(message['device_id'])
		assert 'endpoint_uuid' in message
		validate_uuid(message['endpoint_uuid'])

		def validate_topology_id(message):
		assert type(message) is dict
		assert len(message.keys()) == 2
		assert 'contextId' in message
		validate_context_id(message['contextId'])
		assert 'topoId' in message
		validate_uuid(message['topoId'])

		def validate_device_config(message):
		assert type(message) is dict
		# ----- Lists of Identifiers -------------------------------------------------------------------------------------------

		def validate_context_ids(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'device_config' in message
		assert type(message['device_config']) is str
		assert 'context_ids' in message
		assert isinstance(message['context_ids'], list)
		for context_id in message['context_ids']: validate_context_id(context_id)

		def validate_device_operational_status(message):
		assert type(message) is str
		assert message in ['KEEP_STATE', 'ENABLED', 'DISABLED']
		def validate_service_ids(message, context_uuid=None):
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'service_ids' in message
		assert isinstance(message['service_ids'], list)
		for service_id in message['service_ids']: validate_service_id(service_id, context_uuid=context_uuid)

		def validate_endpoint_id(message):
		assert type(message) is dict
		def validate_topology_ids(message, context_uuid=None):
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'topology_ids' in message
		assert isinstance(message['topology_ids'], list)
		for topology_id in message['topology_ids']: validate_topology_id(topology_id, context_uuid=context_uuid)

		def validate_device_ids(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'device_ids' in message
		assert isinstance(message['device_ids'], list)
		for device_id in message['device_ids']: validate_device_id(device_id)

		def validate_link_ids(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'link_ids' in message
		assert isinstance(message['link_ids'], list)
		for link_id in message['link_ids']: validate_link_id(link_id)


		# ----- Objects --------------------------------------------------------------------------------------------------------

		def validate_context(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 3
		assert 'topoId' in message
		validate_topology_id(message['topoId'])
		assert 'dev_id' in message
		validate_device_id(message['dev_id'])
		assert 'port_id' in message
		validate_uuid(message['port_id'])
		assert 'context_id' in message
		validate_context_id(message['context_id'])
		context_uuid = message['context_id']['context_uuid']['uuid']
		assert 'service_ids' in message
		assert isinstance(message['service_ids'], list)
		for service_id in message['service_ids']: validate_service_id(service_id, context_uuid=context_uuid)
		assert 'topology_ids' in message
		assert isinstance(message['topology_ids'], list)
		for topology_id in message['topology_ids']: validate_topology_id(topology_id, context_uuid=context_uuid)

		def validate_service_state(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'service_status' in message
		validate_service_state_enum(message['service_status'])

		def validate_service(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 6
		assert 'service_id' in message
		validate_service_id(message['service_id'])
		assert 'service_type' in message
		validate_service_type_enum(message['service_type'])
		assert 'service_endpoint_ids' in message
		assert isinstance(message['service_endpoint_ids'], list)
		for endpoint_id in message['service_endpoint_ids']: validate_endpoint_id(endpoint_id)
		assert 'service_constraints' in message
		assert isinstance(message['service_constraints'], list)
		for constraint in message['service_constraints']: validate_constraint(constraint)
		assert 'service_status' in message
		validate_service_state(message['service_status'])
		assert 'service_config' in message
		validate_config_rules(message['service_config'])

		def validate_topology(message, num_devices=None, num_links=None):
		assert isinstance(message, dict)
		assert len(message.keys()) == 3
		assert 'topology_id' in message
		validate_topology_id(message['topology_id'])
		assert 'device_ids' in message
		assert isinstance(message['device_ids'], list)
		if num_devices is not None: assert len(message['device_ids']) == num_devices
		for device_id in message['device_ids']: validate_device_id(device_id)
		assert 'link_ids' in message
		assert isinstance(message['link_ids'], list)
		if num_links is not None: assert len(message['link_ids']) == num_links
		for link_id in message['link_ids']: validate_link_id(link_id)

		def validate_endpoint(message):
		assert type(message) is dict
		assert isinstance(message, dict)
		assert len(message.keys()) == 2
		assert 'port_id' in message
		validate_endpoint_id(message['port_id'])
		assert 'port_type' in message
		assert type(message['port_type']) is str
		assert 'endpoint_id' in message
		validate_endpoint_id(message['endpoint_id'])
		assert 'endpoint_type' in message
		assert isinstance(message['endpoint_type'], str)

		def validate_device(message):
		assert type(message) is dict
		assert len(message.keys()) == 5
		assert isinstance(message, dict)
		assert len(message.keys()) == 6
		assert 'device_id' in message
		validate_device_id(message['device_id'])
		assert 'device_type' in message
		assert type(message['device_type']) is str
		assert isinstance(message['device_type'], str)
		assert 'device_config' in message
		validate_device_config(message['device_config'])
		assert 'devOperationalStatus' in message
		validate_device_operational_status(message['devOperationalStatus'])
		assert 'endpointList' in message
		assert type(message['endpointList']) is list
		for endpoint in message['endpointList']: validate_endpoint(endpoint)
		validate_config_rules(message['device_config'])
		assert 'device_operational_status' in message
		validate_device_operational_status_enum(message['device_operational_status'])
		assert 'device_drivers' in message
		assert isinstance(message['device_drivers'], list)
		for driver in message['device_drivers']: validate_device_driver_enum(driver)
		assert 'device_endpoints' in message
		assert isinstance(message['device_endpoints'], list)
		for endpoint in message['device_endpoints']: validate_endpoint(endpoint)

		def validate_link(message):
		assert type(message) is dict
		assert isinstance(message, dict)
		assert len(message.keys()) == 2
		assert 'link_id' in message
		validate_link_id(message['link_id'])
		assert 'endpointList' in message
		assert type(message['endpointList']) is list
		for endpoint_id in message['endpointList']: validate_endpoint_id(endpoint_id)

		def validate_topology(message):
		assert type(message) is dict
		assert len(message.keys()) > 0
		assert 'topoId' in message
		validate_topology_id(message['topoId'])
		assert 'device' in message
		assert type(message['device']) is list
		for device in message['device']: validate_device(device)
		assert 'link' in message
		assert type(message['link']) is list
		for link in message['link']: validate_link(link)

		def validate_topology_is_empty(message):
		validate_topology(message)
		assert len(message['device']) == 0
		assert len(message['link']) == 0

		def validate_topology_has_devices(message):
		validate_topology(message)
		assert len(message['device']) > 0

		def validate_topology_has_links(message):
		validate_topology(message)
		assert len(message['link']) > 0
		assert 'link_endpoint_ids' in message
		assert isinstance(message['link_endpoint_ids'], list)
		for endpoint_id in message['link_endpoint_ids']: validate_endpoint_id(endpoint_id)

		def validate_constraint(message):
		assert type(message) is dict
		assert len(message.keys()) == 2
		assert 'constraint_type' in message
		assert type(message['constraint_type']) is str
		assert 'constraint_value' in message
		assert type(message['constraint_value']) is str

		def validate_service_id(message):
		assert type(message) is dict
		assert len(message.keys()) == 2
		assert 'contextId' in message
		validate_context_id(message['contextId'])
		assert 'cs_id' in message
		validate_uuid(message['cs_id'])
		# ----- Lists of Objects -----------------------------------------------------------------------------------------------

		def validate_service_config(message):
		assert type(message) is dict
		def validate_contexts(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'serviceConfig' in message
		assert type(message['serviceConfig']) is str
		assert 'contexts' in message
		assert isinstance(message['contexts'], list)
		for context in message['contexts']: validate_context(context)

		def validate_service_type(message):
		assert type(message) is str
		assert message in ['UNKNOWN', 'L3NM', 'L2NM', 'TAPI_CONNECTIVITY_SERVICE']
		def validate_services(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'services' in message
		assert isinstance(message['services'], list)
		for service in message['services']: validate_service(service)

		def validate_service_state_enum(message):
		assert type(message) is str
		assert message in ['PLANNED', 'ACTIVE', 'PENDING_REMOVAL']
		def validate_topologies(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'topologies' in message
		assert isinstance(message['topologies'], list)
		for topology in message['topologies']: validate_topology(topology)

		def validate_service_state(message):
		assert type(message) is dict
		def validate_devices(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'serviceState' in message
		validate_service_state_enum(message['serviceState'])
		assert 'devices' in message
		assert isinstance(message['devices'], list)
		for device in message['devices']: validate_device(device)

		def validate_service(message):
		assert type(message) is dict
		assert len(message.keys()) == 6
		assert 'cs_id' in message
		validate_service_id(message['cs_id'])
		assert 'serviceType' in message
		validate_service_type(message['serviceType'])
		assert 'endpointList' in message
		assert type(message['endpointList']) is list
		for endpoint_id in message['endpointList']: validate_endpoint_id(endpoint_id)
		assert 'constraint' in message
		assert type(message['constraint']) is list
		for constraint in message['constraint']: validate_constraint(constraint)
		assert 'serviceState' in message
		validate_service_state(message['serviceState'])
		assert 'serviceConfig' in message
		validate_service_config(message['serviceConfig'])

		def validate_service_list(message):
		assert type(message) is dict
		assert len(message.keys()) == 1
		assert 'cs' in message
		assert type(message['cs']) is list
		for cs in message['cs']: validate_service(cs)

		def validate_service_list_is_empty(message):
		validate_service_list(message)
		assert len(message['cs']) == 0

		def validate_service_list_is_not_empty(message):
		validate_service_list(message)
		assert len(message['cs']) > 0
		def validate_links(message):
		assert isinstance(message, dict)
		assert len(message.keys()) == 1
		assert 'links' in message
		assert isinstance(message['links'], list)
		for link in message['links']: validate_link(link)