class TransactionMain: def __init__(self): self.configuration = TransactionConfiguration() self.configuration.loadEnvironment() self.transactionLirePika = PikaDAO(self.configuration) self.callbackImpl = CallbackNouvelleTransaction() def connecter(self): self.connexionMq = self.transactionLirePika.connecter() self.transactionLirePika.demarrer_lecture_nouvelles_transactions( self.callbackImpl.callbackAvecAck) def deconnecter(self): self.transactionLirePika.deconnecter() # Methode principale de traitement def run(self): print("Demarrage du traitement des transactions MQ -> MongoDB") print("MQ Host: %s, MQ Queue: %s" % (self.configuration.mq_host, self.configuration.queue_nouvelles_transactions)) self.connecter() print("Fin execution transactions MQ -> MongoDB")
class NotificationActionExempleTest: def __init__(self): self.configuration = TransactionConfiguration() self.configuration.loadEnvironment() self.message_dao = PikaDAO(self.configuration) self.message_dao.connecter() self.generateur_transaction = GenerateurTransaction(self.configuration, self.message_dao) def deconnecter(self): self.message_dao.deconnecter() def test1(self): # temps_lecture_ajuste = temps_lecture + datetime.timedelta(hours=4) domaine = TachesConstantes.TRANSACTION_ACTION_TACHE transaction_message = dict({ TachesConstantes.LIBELLE_ID_NOTIFICATION: '5c152457e094095d8c8d314e', TachesConstantes.LIBELLE_ACTION: TachesConstantes.ACTION_VUE, TachesConstantes.LIBELLE_DATE_ATTENTE_ACTION: 180 }) self.generateur_transaction.soumettre_transaction(transaction_message, domaine) print("Sent notification domaine %s: %s" % (domaine, transaction_message))
def __init__(self): self._client = None self._logger = logging.getLogger('TesterCertificatsMongoDB') self._configuration = dict() self.configuration = TransactionConfiguration() self.mongo_dao = None
def __init__(self): self.configuration = TransactionConfiguration() self.configuration.loadEnvironment() self.message_dao = PikaDAO(self.configuration) self.message_dao.connecter() self.generateur_transaction = GenerateurTransaction(self.configuration, self.message_dao)
def __init__(self): self.configuration = TransactionConfiguration() self.configuration.loadEnvironment() print("Connection MongDB") self.document_dao = MongoDAO(self.configuration) self.document_dao.connecter() print("Connecter Pika") self.message_dao = PikaDAO(self.configuration) self.message_dao.connecter() self._traitement = TraitementBacklogLecturesSenseursPassifs( self.message_dao, self.document_dao)
def __init__(self): configuration = TransactionConfiguration() configuration.loadEnvironment() document_dao = MongoDAO(configuration) document_dao.connecter() document_ids = ['5bef321b82cc2cb5ab0e33c2', '5bef323482cc2cb5ab0e995d'] super().__init__(configuration, document_dao, document_ids=document_ids, intervalle_secs=5)
def __init__(self): self.configuration = TransactionConfiguration() self.configuration.loadEnvironment() print("Connecter Pika") self.messageDao = PikaDAO(self.configuration) self.messageDao.connecter() print("Connection MongDB") self.documentDao = MongoDAO(self.configuration) self.documentDao.connecter() self.producteur = ProducteurDocumentSenseurPassif( self.messageDao, self.documentDao)
def connecter(self): gestionnaire_docker = self.__service_monitor.gestionnaire_docker config_connexion_docker = gestionnaire_docker.charger_config_recente('millegrille.connexion')['config'] config_connexion = json.loads(b64decode(config_connexion_docker.attrs['Spec']['Data'])) # clecert_monitor = self.__service_monitor.clc gestionnaire_certificats = self.__service_monitor.gestionnaire_certificats certificats = gestionnaire_certificats.certificats path_secrets = gestionnaire_certificats.secret_path ca_certs_file = certificats['pki.millegrille.cert'] monitor_cert_file = certificats['pki.%s.cert' % ConstantesGenerateurCertificat.ROLE_MONITOR_DEPENDANT] monitor_key_file = path.join(path_secrets, ConstantesServiceMonitor.DOCKER_CONFIG_MONITOR_DEPENDANT_KEY + '.pem') node_name = config_connexion['principal_mq_url'] additionnals = [{ 'MG_MQ_HOST': node_name, 'MG_MQ_PORT': 5673, 'MG_MQ_CA_CERTS': ca_certs_file, 'MG_MQ_CERTFILE': monitor_cert_file, 'MG_MQ_KEYFILE': monitor_key_file, 'MG_MQ_SSL': 'on', 'MG_MQ_AUTH_CERT': 'on', }] configuration = TransactionConfiguration() self.__contexte = ContexteRessourcesMilleGrilles(configuration=configuration, additionals=additionnals) # Connecter a MQ du noeud principal self.__contexte.initialiser(init_message=True, connecter=True) self.__traitement_messages_principal = TraitementMessagesConnexionPrincipale(self.__service_monitor, self.__contexte) self.__contexte.message_dao.register_channel_listener(self.__traitement_messages_principal)
class AggregationSenseursDocumentTest: def __init__(self): self.configuration = TransactionConfiguration() self.configuration.loadEnvironment() print("Connecter Pika") self.messageDao = PikaDAO(self.configuration) self.messageDao.connecter() print("Connection MongDB") self.documentDao = MongoDAO(self.configuration) self.documentDao.connecter() self.producteur = ProducteurDocumentSenseurPassif( self.messageDao, self.documentDao) def run(self): id_documents = self.producteur.trouver_id_documents_senseurs() print("Documents: %s" % str(id_documents))
class TesterCertificatsMongoDB: def __init__(self): self._client = None self._logger = logging.getLogger('TesterCertificatsMongoDB') self._configuration = dict() self.configuration = TransactionConfiguration() self.mongo_dao = None def connecter(self): self._client = MongoClient(**self._configuration) self._logger.debug("Verify if connection established") self._client.admin.command('ismaster') def connecter_mongodao(self): self.mongo_dao = MongoDAO(self.configuration) self._client = self.mongo_dao.connecter() def preparer_configuration_interne(self): self._configuration['host'] = 'think003.pivoine.mdugre.info' self._configuration['port'] = 27017 self._configuration['username'] = '******' self._configuration['password'] = '******' self._configuration['ssl'] = True self._configuration['ssl_cert_reqs'] = ssl.CERT_REQUIRED self._configuration[ 'ssl_certfile'] = '/usr/local/etc/millegrilles/certs/keys/millegrilles.pem.key_cert' self._configuration[ 'ssl_ca_certs'] = '/usr/local/etc/millegrilles/certs/millegrilles.authority.pem' def preparer_configuration_objet(self): self.configuration.loadEnvironment() self._configuration = self.configuration.format_mongo_config() self._logger.info("Configuration Mongo: %s" % str(self._configuration)) def lire_document(self): coll_allo = self.mongo_dao.get_collection('coll_allo') # doc = {'key': 'value', 'message': 'Super!'} # coll_allo.insert_one(doc) doc = coll_allo.find_one(filter={'key': 'value'}) self._logger.info('Document trouve: %s' % str(doc))
class SenseursPassifsRequetesTest: def __init__(self): self.configuration = TransactionConfiguration() self.configuration.loadEnvironment() print("Connection MongDB") self.document_dao = MongoDAO(self.configuration) self.document_dao.connecter() print("Connecter Pika") self.message_dao = PikaDAO(self.configuration) self.message_dao.connecter() self._traitement = TraitementBacklogLecturesSenseursPassifs( self.message_dao, self.document_dao) def run_requete_plusrecentetransactionlecture_parsenseur(self): return self._traitement.run_requete_plusrecentetransactionlecture_parsenseur( ) def run_requete_genererdeclencheur_parsenseur(self, liste_senseurs): self._traitement.run_requete_genererdeclencheur_parsenseur( liste_senseurs)
class NotificationExempleTest: def __init__(self): self.configuration = TransactionConfiguration() self.configuration.loadEnvironment() self.message_dao = PikaDAO(self.configuration) self.message_dao.connecter() def deconnecter(self): self.message_dao.deconnecter() def test1(self): # temps_lecture_ajuste = temps_lecture + datetime.timedelta(hours=4) notification = dict({ '_mg-libelle': 'regle_simple', 'evenements': Constantes.EVENEMENT_NOTIFICATION, 'source': { '_collection': 'mgdomaines_appareils_SenseursPassifs', '_id': "5bef31be82cc2cb5ab0d57fe" }, 'regles': [{ "pasbonne_10": { "element": "temperature" } }], "date": int(datetime.datetime.utcnow().timestamp()), 'valeurs': { "element": "temperature", "valeur": 24.6 } }) self.message_dao.transmettre_notification( notification, TachesConstantes.AVERTISSEMENT) print("Sent notification: %s" % notification)
def message_test(): message_test = { Constantes.TRANSACTION_MESSAGE_LIBELLE_ID_MONGO: "5bee12bce09409b7881c0da4" } processus = "mgdomaines_appareils_SenseursPassifs:ProcessusTransactionSenseursPassifsLecture" demarreur.demarrer_processus(processus, message_test) return message_test # --- MAIN --- configuration = TransactionConfiguration() configuration.loadEnvironment() print("Connecter Pika") messageDao = PikaDAO(configuration) messageDao.connecter() print("Connection MongDB") documentDao = MongoDAO(configuration) documentDao.connecter() print("Envoyer message") demarreur = MGPProcessusDemarreur(messageDao, documentDao) # TEST enveloppe = message_test()
from millegrilles.dao.DocumentDAO import MongoDAO from millegrilles.dao.Configuration import TransactionConfiguration from millegrilles.dao.MessageDAO import PikaDAO configuration = TransactionConfiguration() messageDao = PikaDAO(configuration) mongoDao = MongoDAO(configuration) mongoDao.connecter() transaction_helper = mongoDao.transaction_helper() print("Connecte a Mongo") message_dummy = {"contenu": "valeur"} enveloppe = message_dummy mongo_id = transaction_helper.sauvegarder_nouvelle_transaction( mongoDao._collection_transactions, enveloppe) print("Document Mongo id=%s a ete cree" % mongo_id) mongoDao.deconnecter() print("Deconnecte de Mongo")
class TestCertificatsRabbitMQ: def __init__(self): self.configuration = TransactionConfiguration() self.connectionmq = None self.channel = None self.message_dao = None def configurer(self): self.configuration.loadEnvironment() self.message_dao = PikaDAO(self.configuration) def preparer_connexion(self): connection_parameters = { 'host': self.configuration.mq_host, 'port': self.configuration.mq_port, 'virtual_host': self.configuration.idmg, 'heartbeat': 300 } credentials = { 'username': self.configuration.mq_user, 'password': self.configuration.mq_password, 'erase_on_connect': True } connection_parameters['credentials'] = PlainCredentials(**credentials) if self.configuration.mq_ssl == 'on': # verify_mode = ssl.CERT_NONE # server_hostname = None ssl_options = { 'ssl_version': ssl.PROTOCOL_TLSv1_2, 'keyfile': '/usr/local/etc/millegrilles/certs/keys/think003.pivoine.mdugre.info.pem', 'certfile': '/usr/local/etc/millegrilles/certs/think003.pivoine.mdugre.info.cert.pem', 'ca_certs': '/usr/local/etc/millegrilles/certs/millegrilles.authority.pem', 'cert_reqs': ssl.CERT_REQUIRED } connection_parameters['ssl'] = True connection_parameters['ssl_options'] = ssl_options return connection_parameters def connecter_test(self): connection_parameters = pika.ConnectionParameters( **self.preparer_connexion()) self.connectionmq = pika.BlockingConnection(connection_parameters) def connecter_dao(self): self.connectionmq = self.message_dao.connecter() def verifier_connexion(self): self.channel = self.connectionmq.channel() self.channel.basic_qos(prefetch_count=1) def transmettre_message(self): pass def fermer(self): self.connectionmq.close()
def __init__(self): self.configuration = TransactionConfiguration() self.configuration.loadEnvironment() self.transactionLirePika = PikaDAO(self.configuration) self.callbackImpl = CallbackNouvelleTransaction()
def __init__(self): self.configuration = TransactionConfiguration() self.connectionmq = None self.channel = None self.message_dao = None
from millegrilles.dao.Configuration import TransactionConfiguration class TestNoms: def test_nom_module(self): print(instance.__class__.__module__.replace(".", "_")) instance = TransactionConfiguration() test = TestNoms() test.test_nom_module()