def __init__(self, device_id):
self.logger = Utils.create_logger("certificate")
self.jwt = RedisClient().get_jwt()
self.c_name = device_id
self.key = {"pem": self.generate_private_key()}
self.csr = {"pem": self.generate_csr()}
self.crt = {}
self.crt["fingerprint"], self.crt["pem"] = self.generate_certificate()
def __init__(self, device_id: str, run_id: str, should_revoke: bool,
should_renew: bool):
"""
MQTT client constructor. To get this to work, you should call setup() after instantiating
the class.
Args:
device_id: device identifier
run_id: client run identifier
should_revoke: whether this client should have its certificate revoked
should_renew: whether this client should have its certificate renewed
"""
self.logger = Utils.create_logger("mqtt_client")
Utils.validate_tenant(CONFIG["app"]["tenant"])
Utils.validate_device_id(device_id)
if len(run_id) < 1:
raise ValueError("the run ID must have at least one character")
if should_renew and should_revoke:
raise ValueError(
"only one of should_renew and should_revoke can be True")
self.device_id = device_id
self.run_id = run_id
self.should_revoke = should_revoke
self.should_renew = should_renew
self.is_renewed = False
self.is_revoked = False
self.is_connected = False
# If this variable is set, the on_disconnect callback will not try to reconnect
# the device again
self.disconnect_forever = False
self.mqttc = None
self.tenant = CONFIG["app"]["tenant"]
self.username = '******'.format(self.tenant, self.device_id)
self.topic = "{0}/attrs".format(self.username)
self.sub_topic = "{0}/config".format(self.username)
self.device_cert_dir = CONFIG["security"]["cert_dir"]
self.new_cert = None
self.pubmmap = {}
self.submmap = {}
# Used to count the time between connection and revocation/renovation
self.start_time = 0
self.create_certificate()
self.configure_mqtt()
def __init__(self) -> None:
"""
Attempts to stablish a connection.
"""
self.logger = Utils.create_logger("redis_client")
try:
self.certificates = redis.Redis(
host=CONFIG['locust']['redis']['host'],
port=CONFIG['locust']['redis']['port'],
db=CONFIG['locust']['redis']['certificates_db'])
self.mapped = redis.Redis(
host=CONFIG['locust']['redis']['host'],
port=CONFIG['locust']['redis']['port'],
db=CONFIG['locust']['redis']['mapped_db'])
except Exception as exception:
self.logger.error(str(exception))
raise
def test_create_logger(self, mock_os_env_get, mock_formatter,
mock_stream_handler, mock_get_logger):
"""
create_logger() should create a logger with the supplied name.
"""
mock_os_env_get.get.return_value = "info"
logger_name = "test_logger"
logger = Utils.create_logger(name=logger_name)
mock_get_logger.assert_called_with(logger_name)
mock_stream_handler.assert_called_once()
mock_formatter.assert_called_once()
self.assertTrue(logger.hasHandlers())
mock_os_env_get.reset_mock()
mock_formatter.reset_mock()
mock_stream_handler.reset_mock()
mock_get_logger.reset_mock()
from multiprocessing import Process
import time
import uuid
import shutil
import sys
import os
import redis
from typing import List, Tuple
import requests
from src.ejbca.thing import Thing
from src.config import CONFIG
from src.utils import Utils
from src.dojot.api import DojotAPI
LOGGER = Utils.create_logger("generate_cert")
class GenerateCerts():
"""
Certificate and Dojot certificate/device manager.
"""
def __init__(self):
"""
Creates the parsers and subparsers.
"""
parser = argparse.ArgumentParser()
# Creating subparsers
subparsers = parser.add_subparsers(dest="topic")
"""
API calls to Dojot.
"""
import json
from typing import Callable, List, Dict
import sys
import requests
import gevent
from src.config import CONFIG
from src.utils import Utils
LOGGER = Utils.create_logger("api")
class APICallError(Exception):
"""
Error when trying to call Dojot API.
"""
class DojotAPI():
"""
Utility class with API calls to Dojot.
"""
@staticmethod
def get_jwt() -> str:
"""
Request a JWT token.
"""
url = "{0}/auth".format(CONFIG['dojot']['url'])
"""
Certificate utilities.
"""
import os
import requests
from src.config import CONFIG
from src.utils import Utils
from src.ejbca.thing import Thing
from src.mqtt_locust.redis_client import RedisClient
LOGGER = Utils.create_logger("cert_utils")
class CertUtils:
"""
Handles certificate-related operations.
"""
@staticmethod
def get_private_key_file(device_id: str) -> str:
"""
Creates the key filename.
"""
Utils.validate_device_id(device_id)
return "{0}.key".format(device_id)
@staticmethod
def get_certificate_file(device_id: str) -> str:
"""
Creates the certificate filename.
"""
