src/load_generator/service/__main__.py

@@ -53,7 +53,7 @@ def main():
     grpc_service.start()
 
     # Wait for Ctrl+C or termination signal
-    while not terminate.wait(timeout=0.1): pass
+    while not terminate.wait(timeout=1.0): pass
 
     scheduler = grpc_service.load_generator_servicer._scheduler
     if scheduler is not None: scheduler.stop()

src/monitoring/service/MetricsDBTools.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import time
+import math
 from random import random
 
 from questdb.ingress import Sender, IngressError
@@ -326,4 +327,4 @@ class MetricsDB():
             else:
                 LOGGER.debug(f"No new data for the alarm of KPI {kpi_id}")
         except (Exception) as e:
-            LOGGER.debug(f"Alarm data cannot be retrieved. {e}")
+            LOGGER.debug(f"Alarm data cannot be retrieved. {e}")
\ No newline at end of file

src/monitoring/service/__main__.py

@@ -91,7 +91,7 @@ def main():
     start_monitoring(name_mapping)
 
     # Wait for Ctrl+C or termination signal
-    while not terminate.wait(timeout=0.1): pass
+    while not terminate.wait(timeout=1.0): pass
 
     LOGGER.info('Terminating...')
     grpc_service.stop()

src/opticalattackdetector/.gitlab-ci.yml

+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# 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.
+
+# build, tag and push the Docker image to the gitlab registry
+build opticalattackdetector:
+  variables:
+    IMAGE_NAME: 'opticalattackdetector' # name of the microservice
+    IMAGE_TAG: 'latest' # tag of the container image (production, development, etc)
+  stage: build
+  before_script:
+    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
+  script:
+    - docker build -t "$IMAGE_NAME:$IMAGE_TAG" -f ./src/$IMAGE_NAME/Dockerfile .
+    - docker tag "$IMAGE_NAME:$IMAGE_TAG" "$CI_REGISTRY_IMAGE/$IMAGE_NAME:$IMAGE_TAG"
+    - docker push "$CI_REGISTRY_IMAGE/$IMAGE_NAME:$IMAGE_TAG"
+  after_script:
+    - docker images --filter="dangling=true" --quiet | xargs -r docker rmi
+  rules:
+    - if: '$CI_PIPELINE_SOURCE == "merge_request_event" && ($CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "develop" || $CI_MERGE_REQUEST_TARGET_BRANCH_NAME == $CI_DEFAULT_BRANCH)'
+    - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == "develop"' 
+    - changes:
+      - src/$IMAGE_NAME/**/*.{py,in,yml}
+      - src/$IMAGE_NAME/Dockerfile
+      - src/$IMAGE_NAME/tests/*.py
+      - src/$IMAGE_NAME/tests/Dockerfile
+      - manifests/${IMAGE_NAME}service.yaml
+      - .gitlab-ci.yml
+
+# apply unit test to the opticalattackdetector component
+unit_test opticalattackdetector:
+  variables:
+    IMAGE_NAME: 'opticalattackdetector' # name of the microservice
+    IMAGE_TAG: 'latest' # tag of the container image (production, development, etc)
+  stage: unit_test
+  needs:
+    - build opticalattackdetector
+  before_script:
+    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
+    - if docker network list | grep teraflowbridge; then echo "teraflowbridge is already created"; else docker network create -d bridge teraflowbridge; fi
+    - if docker container ls | grep $IMAGE_NAME; then docker rm -f $IMAGE_NAME; else echo "$IMAGE_NAME image is not in the system"; fi
+  script:
+    - docker pull "$CI_REGISTRY_IMAGE/$IMAGE_NAME:$IMAGE_TAG"
+    - docker run --name $IMAGE_NAME -d -p 10006:10006 --env-file "$PWD/src/$IMAGE_NAME/.env" -v "$PWD/src/$IMAGE_NAME/tests:/home/${IMAGE_NAME}/results" --network=teraflowbridge --rm $CI_REGISTRY_IMAGE/$IMAGE_NAME:$IMAGE_TAG
+    - sleep 5
+    - docker ps -a
+    - docker logs $IMAGE_NAME
+    - docker exec -i $IMAGE_NAME bash -c "coverage run -m pytest --log-level=DEBUG --verbose $IMAGE_NAME/tests/test_unitary.py --junitxml=/home/${IMAGE_NAME}/results/${IMAGE_NAME}_report.xml; coverage xml -o /home/${IMAGE_NAME}/results/${IMAGE_NAME}_coverage.xml; coverage report --include='${IMAGE_NAME}/*' --show-missing"
+  coverage: '/TOTAL\s+\d+\s+\d+\s+(\d+%)/'
+  after_script:
+    - docker rm -f $IMAGE_NAME
+    - docker network rm teraflowbridge
+  rules:
+    - if: '$CI_PIPELINE_SOURCE == "merge_request_event" && ($CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "develop" || $CI_MERGE_REQUEST_TARGET_BRANCH_NAME == $CI_DEFAULT_BRANCH)'
+    - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == "develop"' 
+    - changes:
+      - src/$IMAGE_NAME/**/*.{py,in,yml}
+      - src/$IMAGE_NAME/Dockerfile
+      - src/$IMAGE_NAME/tests/*.py
+      - src/$IMAGE_NAME/tests/Dockerfile
+      - manifests/${IMAGE_NAME}service.yaml
+      - .gitlab-ci.yml
+  artifacts:
+    when: always
+    reports:
+      junit: src/$IMAGE_NAME/tests/${IMAGE_NAME}_report.xml
+
+
+# Deployment of the opticalattackdetector service in Kubernetes Cluster
+# deploy opticalattackdetector:
+#   variables:
+#     IMAGE_NAME: 'opticalattackdetector' # name of the microservice
+#     IMAGE_TAG: 'latest' # tag of the container image (production, development, etc)
+#   stage: deploy
+#   needs:
+#     - unit test opticalattackdetector
+#     # - integ_test execute
+#   script:
+#     - 'sed -i "s/$IMAGE_NAME:.*/$IMAGE_NAME:$IMAGE_TAG/" manifests/${IMAGE_NAME}service.yaml'
+#     - kubectl version
+#     - kubectl get all
+#     - kubectl apply -f "manifests/${IMAGE_NAME}service.yaml"
+#     - kubectl get all
+#   # environment:
+#   #   name: test
+#   #   url: https://example.com
+#   #   kubernetes:
+#   #     namespace: test
+#   rules:
+#     - if: '$CI_PIPELINE_SOURCE == "merge_request_event" && ($CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "develop" || $CI_MERGE_REQUEST_TARGET_BRANCH_NAME == $CI_DEFAULT_BRANCH)'
+#       when: manual    
+#     - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == "develop"'
+#       when: manual
\ No newline at end of file

src/opticalattackdetector/Config.py

+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# 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.

src/opticalcentralizedattackdetector/Dockerfile → src/opticalattackdetector/Dockerfile

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-FROM python:3-slim
+FROM python:3.9-slim
 
 # Install dependencies
 RUN apt-get --yes --quiet --quiet update && \
@@ -21,36 +21,68 @@ RUN apt-get --yes --quiet --quiet update && \
 
 # Set Python to show logs as they occur
 ENV PYTHONUNBUFFERED=0
+ENV PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python
 
 # Download the gRPC health probe
 RUN GRPC_HEALTH_PROBE_VERSION=v0.2.0 && \
     wget -qO/bin/grpc_health_probe https://github.com/grpc-ecosystem/grpc-health-probe/releases/download/${GRPC_HEALTH_PROBE_VERSION}/grpc_health_probe-linux-amd64 && \
     chmod +x /bin/grpc_health_probe
 
+# Creating a user for security reasons
+RUN groupadd -r teraflow && useradd -u 1001 --no-log-init -r -m -g teraflow teraflow
+USER teraflow
+
+# set working directory
+RUN mkdir -p /home/teraflow/controller/common/
+WORKDIR /home/teraflow/controller
+
+# Get Python packages per module
+ENV VIRTUAL_ENV=/home/teraflow/venv
+RUN python3 -m venv ${VIRTUAL_ENV}
+ENV PATH="${VIRTUAL_ENV}/bin:${PATH}"
+
 # Get generic Python packages
-RUN python3 -m pip install --upgrade pip setuptools wheel pip-tools
+RUN python3 -m pip install --upgrade pip
+RUN python3 -m pip install --upgrade setuptools wheel
+RUN python3 -m pip install --upgrade pip-tools
+
+# Get common Python packages
+# Note: this step enables sharing the previous Docker build steps among all the Python components
+COPY --chown=teraflow:teraflow common_requirements.in common_requirements.in
+RUN pip-compile --quiet --output-file=common_requirements.txt common_requirements.in
+RUN python3 -m pip install -r common_requirements.txt
 
-# Set working directory
-WORKDIR /var/teraflow
+# Add common files into working directory
+WORKDIR /home/teraflow/controller/common
+COPY --chown=teraflow:teraflow src/common/. ./
+RUN rm -rf proto
+
+# Create proto sub-folder, copy .proto files, and generate Python code
+RUN mkdir -p /home/teraflow/controller/common/proto
+WORKDIR /home/teraflow/controller/common/proto
+RUN touch __init__.py
+COPY --chown=teraflow:teraflow proto/*.proto ./
+RUN python3 -m grpc_tools.protoc -I=. --python_out=. --grpc_python_out=. *.proto
+RUN rm *.proto
+RUN find . -type f -exec sed -i -E 's/(import\ .*)_pb2/from . \1_pb2/g' {} \;
 
 # Create module sub-folders
-RUN mkdir -p /var/teraflow/opticalcentralizedattackdetector
+RUN mkdir -p /home/teraflow/controller/opticalattackdetector
+WORKDIR /home/teraflow/controller
 
 # Get Python packages per module
-COPY opticalcentralizedattackdetector/requirements.in opticalcentralizedattackdetector/requirements.in
-RUN pip-compile --output-file=opticalcentralizedattackdetector/requirements.txt opticalcentralizedattackdetector/requirements.in
-RUN python3 -m pip install -r opticalcentralizedattackdetector/requirements.txt
-
-# Add files into working directory
-COPY common/. common
-COPY context/. context
-COPY monitoring/. monitoring
-COPY service/. service
-COPY dbscanserving/. dbscanserving
-COPY opticalattackmitigator/. opticalattackmitigator
-COPY opticalcentralizedattackdetector/. opticalcentralizedattackdetector
+COPY --chown=teraflow:teraflow ./src/opticalattackdetector/requirements.in opticalattackdetector/requirements.in
+# consider common and specific requirements to avoid inconsistencies with dependencies
+RUN pip-compile --quiet --output-file=opticalattackdetector/requirements.txt opticalattackdetector/requirements.in common_requirements.in
+RUN python3 -m pip install -r opticalattackdetector/requirements.txt
 
-ENV PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python
+# Add component files into working directory
+COPY --chown=teraflow:teraflow ./src/context/. context
+COPY --chown=teraflow:teraflow ./src/service/. service
+COPY --chown=teraflow:teraflow ./src/monitoring/. monitoring
+COPY --chown=teraflow:teraflow ./src/dbscanserving/. dbscanserving
+COPY --chown=teraflow:teraflow ./src/opticalattackmitigator/. opticalattackmitigator
+COPY --chown=teraflow:teraflow ./src/opticalattackdetector/. opticalattackdetector
 
-# Start opticalcentralizedattackdetector service
-ENTRYPOINT ["python", "-m", "opticalcentralizedattackdetector.service"]
+# Start the service
+ENTRYPOINT ["python", "-m", "opticalattackdetector.service"]

src/dbscanserving/proto/__init__.py → src/opticalattackdetector/__init__.py

@@ -11,4 +11,3 @@
 # 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.
-

src/opticalcentralizedattackdetector/client/OpticalCentralizedAttackDetectorClient.py → src/opticalattackdetector/client/OpticalAttackDetectorClient.py

@@ -12,59 +12,58 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import grpc, logging
-from common.tools.client.RetryDecorator import retry, delay_exponential
-from opticalcentralizedattackdetector.proto.context_pb2 import Empty, Service
-from opticalcentralizedattackdetector.proto.monitoring_pb2 import KpiList
-from opticalcentralizedattackdetector.proto.optical_centralized_attack_detector_pb2_grpc import OpticalCentralizedAttackDetectorServiceStub
+import logging
+
+import grpc
+
+from common.Constants import ServiceNameEnum
+from common.proto.context_pb2 import Empty
+from common.proto.optical_attack_detector_pb2_grpc import \
+    OpticalAttackDetectorServiceStub
+from common.Settings import get_service_host, get_service_port_grpc
+from common.tools.client.RetryDecorator import delay_exponential, retry
+from common.tools.grpc.Tools import grpc_message_to_json
 
 LOGGER = logging.getLogger(__name__)
 MAX_RETRIES = 15
 DELAY_FUNCTION = delay_exponential(initial=0.01, increment=2.0, maximum=5.0)
-RETRY_DECORATOR = retry(max_retries=MAX_RETRIES, delay_function=DELAY_FUNCTION, prepare_method_name='connect')
+RETRY_DECORATOR = retry(
+    max_retries=MAX_RETRIES,
+    delay_function=DELAY_FUNCTION,
+    prepare_method_name="connect",
+)
+
 
-class OpticalCentralizedAttackDetectorClient:
-    def __init__(self, address, port):
-        self.endpoint = '{:s}:{:s}'.format(str(address), str(port))
-        LOGGER.debug('Creating channel to {:s}...'.format(str(self.endpoint)))
+class OpticalAttackDetectorClient:
+    def __init__(self, host=None, port=None):
+        if not host:
+            host = get_service_host(ServiceNameEnum.OPTICALATTACKDETECTOR)
+        if not port:
+            port = get_service_port_grpc(ServiceNameEnum.OPTICALATTACKDETECTOR)
+        self.endpoint = "{:s}:{:s}".format(str(host), str(port))
+        LOGGER.debug("Creating channel to {:s}...".format(str(self.endpoint)))
         self.channel = None
         self.stub = None
         self.connect()
-        LOGGER.debug('Channel created')
+        LOGGER.debug("Channel created")
 
     def connect(self):
         self.channel = grpc.insecure_channel(self.endpoint)
-        self.stub = OpticalCentralizedAttackDetectorServiceStub(self.channel)
+        self.stub = OpticalAttackDetectorServiceStub(self.channel)
 
     def close(self):
-        if(self.channel is not None): self.channel.close()
+        if self.channel is not None:
+            self.channel.close()
         self.channel = None
         self.stub = None
 
     @RETRY_DECORATOR
-    def NotifyServiceUpdate(self, request : Service) -> Empty:
-        LOGGER.debug('NotifyServiceUpdate request: {:s}'.format(str(request)))
-        response = self.stub.NotifyServiceUpdate(request)
-        LOGGER.debug('NotifyServiceUpdate result: {:s}'.format(str(response)))
-        return response
-
-    @RETRY_DECORATOR
-    def DetectAttack(self, request : Empty) -> Empty:
-        LOGGER.debug('DetectAttack request: {:s}'.format(str(request)))
+    def DetectAttack(self, request: Empty) -> Empty:
+        LOGGER.debug(
+            "DetectAttack request: {:s}".format(str(grpc_message_to_json(request)))
+        )
         response = self.stub.DetectAttack(request)
-        LOGGER.debug('DetectAttack result: {:s}'.format(str(response)))
-        return response
-
-    @RETRY_DECORATOR
-    def ReportSummarizedKpi(self, request : KpiList) -> Empty:
-        LOGGER.debug('ReportSummarizedKpi request: {:s}'.format(str(request)))
-        response = self.stub.ReportSummarizedKpi(request)
-        LOGGER.debug('ReportSummarizedKpi result: {:s}'.format(str(response)))
-        return response
-
-    @RETRY_DECORATOR
-    def ReportKpi(self, request : KpiList) -> Empty:
-        LOGGER.debug('ReportKpi request: {:s}'.format(str(request)))
-        response = self.stub.ReportKpi(request)
-        LOGGER.debug('ReportKpi result: {:s}'.format(str(response)))
+        LOGGER.debug(
+            "DetectAttack result: {:s}".format(str(grpc_message_to_json(response)))
+        )
         return response

src/opticalcentralizedattackdetector/client/__init__.py → src/opticalattackdetector/client/__init__.py

@@ -11,4 +11,3 @@
 # 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.
-

src/opticalattackdetector/requirements.in

+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# 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.
+
+numpy
+redis

src/opticalattackdetector/service/OpticalAttackDetectorService.py

+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# 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 logging
+
+from common.Constants import ServiceNameEnum
+from common.proto.optical_attack_detector_pb2_grpc import \
+    add_OpticalAttackDetectorServiceServicer_to_server
+from common.Settings import get_service_port_grpc
+from common.tools.service.GenericGrpcService import GenericGrpcService
+
+from opticalattackdetector.service.OpticalAttackDetectorServiceServicerImpl import \
+    OpticalAttackDetectorServiceServicerImpl
+
+LOGGER = logging.getLogger(__name__)
+
+
+class OpticalAttackDetectorService(GenericGrpcService):
+    def __init__(self, cls_name: str = __name__):
+        port = get_service_port_grpc(ServiceNameEnum.OPTICALATTACKDETECTOR)
+        super().__init__(port, cls_name=cls_name)
+        self.opticalattackdetector_servicer = OpticalAttackDetectorServiceServicerImpl()
+
+    def install_servicers(self):
+        add_OpticalAttackDetectorServiceServicer_to_server(
+            self.opticalattackdetector_servicer, self.server
+        )

src/opticalcentralizedattackdetector/__init__.py → src/opticalattackdetector/service/__init__.py

@@ -11,4 +11,3 @@
 # 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.
-

src/opticalattackdetector/service/__main__.py

+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# 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 logging
+import signal
+import sys
+import threading
+
+from prometheus_client import start_http_server
+
+from common.Constants import ServiceNameEnum
+from common.Settings import (ENVVAR_SUFIX_SERVICE_HOST,
+                             ENVVAR_SUFIX_SERVICE_PORT_GRPC, get_env_var_name,
+                             get_log_level, get_metrics_port,
+                             wait_for_environment_variables)
+
+from opticalattackdetector.client.OpticalAttackDetectorClient import \
+    OpticalAttackDetectorClient
+from opticalattackdetector.service.OpticalAttackDetectorService import \
+    OpticalAttackDetectorService
+
+terminate = threading.Event()
+LOGGER = None
+
+client: OpticalAttackDetectorClient = None
+
+
+def signal_handler(signal, frame):  # pylint: disable=redefined-outer-name
+    LOGGER.warning("Terminate signal received")
+    terminate.set()
+
+
+def main():
+    global LOGGER  # pylint: disable=global-statement
+
+    log_level = get_log_level()
+    logging.basicConfig(level=log_level)
+    LOGGER = logging.getLogger(__name__)
+
+    wait_for_environment_variables(
+        [
+            get_env_var_name(ServiceNameEnum.DBSCANSERVING, ENVVAR_SUFIX_SERVICE_HOST),
+            get_env_var_name(
+                ServiceNameEnum.DBSCANSERVING, ENVVAR_SUFIX_SERVICE_PORT_GRPC
+            ),
+            get_env_var_name(
+                ServiceNameEnum.OPTICALATTACKMITIGATOR, ENVVAR_SUFIX_SERVICE_HOST
+            ),
+            get_env_var_name(
+                ServiceNameEnum.OPTICALATTACKMITIGATOR, ENVVAR_SUFIX_SERVICE_PORT_GRPC
+            ),
+        ]
+    )
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    LOGGER.info("Starting...")
+
+    # Start metrics server
+    metrics_port = get_metrics_port()
+    start_http_server(metrics_port)
+
+    # Starting CentralizedCybersecurity service
+    grpc_service = OpticalAttackDetectorService()
+    grpc_service.start()
+
+    # Wait for Ctrl+C or termination signal
+    while not terminate.wait(timeout=1):
+        pass
+
+    LOGGER.info("Terminating...")
+    grpc_service.stop()
+
+    LOGGER.info("Bye")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

src/opticalattackdetector/tests/__init__.py

+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# 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.

src/opticalattackmanager/Config.py

+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# 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.
+
+MONITORING_INTERVAL = 10  # monitoring interval in seconds