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 __init__(self,
host='localhost',
port=5672,
login='******',
password='******',
virtual_host='/',
loop=None,
**kwargs):
self.loop = loop if loop else ioloop.IOLoop.current()
self.future_store = common.FutureStore(loop=self.loop)
self.__credentials = PlainCredentials(
login, password) if login else ExternalCredentials()
self.__connection_parameters = ConnectionParameters(
host=host,
port=port,
credentials=self.__credentials,
virtual_host=virtual_host,
**kwargs)
self._channels = dict()
self._connection = None
self.__closing = None
self.__close_started = False
self.__write_lock = locks.Lock()
def setup(self):
self.queues = None
self.conn = None
self.channel = None
self.username = self._config['sensor_config']['username']
self.password = self._config['sensor_config']['password']
self.queues = self._config['sensor_config']['queues']
self.host = self._config['sensor_config']['host']
self.deserialization_method = self._config['sensor_config'][
'deserialization_method']
supported_methods = DESERIALIZATION_FUNCTIONS.keys()
if self.deserialization_method and self.deserialization_method not in supported_methods:
raise ValueError('Invalid deserialization method specified: %s' %
(self.deserialization_method))
if self.username and self.password:
credentials = PlainCredentials(username=self.username,
password=self.password)
connection_params = pika.ConnectionParameters(
host=self.host, credentials=credentials)
else:
connection_params = pika.ConnectionParameters(host=self.host)
self.conn = pika.BlockingConnection(connection_params)
self.channel = self.conn.channel()
self.channel.basic_qos(prefetch_count=1)
def __init__(self,
appname,
appclass,
host='localhost',
user='******',
password='******'):
"""Create a new instance of the consumer class, passing in the AMQP
URL used to connect to RabbitMQ.
"""
self._conn_params = pika.ConnectionParameters(
host=host,
credentials=PlainCredentials(user, password),
heartbeat_interval=60)
self.appname = appname
self.appclass = appclass
self.listen_callback = None
self._connection = None
self._channel = None
self._closing = False
self._consumer_tag = None
def __init__(self,
host: str = 'localhost',
port: int = 5672,
login: str = 'guest',
password: str = 'guest',
virtual_host: str = '/',
ssl: bool = False,
*,
loop=None,
**kwargs):
self.loop = loop if loop else asyncio.get_event_loop()
self.future_store = FutureStore(loop=self.loop)
self.__credentials = PlainCredentials(login,
password) if login else None
self.__connection_parameters = ConnectionParameters(
host=host,
port=port,
credentials=self.__credentials,
virtual_host=virtual_host,
ssl=ssl,
**kwargs)
self._channels = dict()
self._connection = None
self.__closing = None
self.__write_lock = asyncio.Lock(loop=self.loop)
def __init__(self,
username: str = "",
password: str = "",
url: str = "",
prefetch_count: int = -2):
if 'sphinx' in sys.modules:
return # don't load when sphinx is running
if username == "":
username = os.environ.get("RABBITMQ_DEFAULT_USER")
if password == "":
password = os.environ.get("RABBITMQ_DEFAULT_PASS")
if url == "":
url = os.environ.get("RABBITMQ_URL", "localhost")
if prefetch_count == -2:
self.prefetch_count = int(os.environ.get("PREFETCH_COUNT", 500))
credentials = PlainCredentials(username=username, password=password)
virtual_host = os.environ.get("RABBITMQ_DEFAULT_VHOST")
params = pika.ConnectionParameters(host=url,
port=5672,
virtual_host=virtual_host,
credentials=credentials,
connection_attempts=10,
retry_delay=10)
self.connection = pika.BlockingConnection(parameters=params)
self.channel = self.connection.channel()
def main():
args = get_arguments()
credentials = None
if args.username and args.password:
credentials = PlainCredentials(args.username, args.password)
parameters = ConnectionParameters(host=args.host,
port=args.port,
credentials=credentials)
connection = BlockingConnection(parameters)
channel = connection.channel()
response = channel.queue_declare(exclusive=True, auto_delete=True)
queue = response.method.queue
channel.queue_bind(exchange=args.exchange,
queue=queue,
routing_key=args.routing_key)
channel.basic_consume(on_message, queue)
try:
channel.start_consuming()
except KeyboardInterrupt:
channel.stop_consuming()
connection.close()
def __init__(self):
# create RabbitMQ broker
self.broker = RabbitmqBroker(host=settings.MESSAGE_QUEUE_HOST,
port=settings.MESSAGE_QUEUE_PORT,
credentials=PlainCredentials(username=settings.MESSAGE_QUEUE_USERNAME,
password=settings.MESSAGE_QUEUE_PASSWORD))
# set the broker as default
set_broker(self.broker)
def __init__(self, config: ConsumerConfig):
super(ParseConsumer, self).__init__(
ConnectionParameters(
host=config.host,
port=config.port,
credentials=PlainCredentials(config.user, config.password),
connection_attempts=3,
heartbeat_interval=20,
))
self.config = config
def consume(self):
connection = pika.BlockingConnection(
pika.ConnectionParameters(host=self.host,
port=self.port,
credentials=PlainCredentials(
self.username, self.password)))
channel = connection.channel()
channel.queue_declare(queue=self.queue, durable=True)
channel.basic_consume(self.callback, self.queue)
channel.start_consuming()
def __init__(self, config: dict = None, ctx=None):
self.context = ctx
self.name = "RabbitMQ Service"
self.retrycount = 1
self.host = config["environment"]["rabbit"]["host"]
credentials = PlainCredentials(
config["environment"]["rabbit"]["username"],
config["environment"]["rabbit"]["password"],
)
self.connection_params = pika.ConnectionParameters(
host=self.host, credentials=credentials,
)
def __init__(self, config: DumpConfig):
self.EXCHANGE = config.queue
self.QUEUE = config.queue
self.ROUTING_KEY = config.queue
super(Dumper, self).__init__(
ConnectionParameters(
host=config.host,
port=config.port,
credentials=PlainCredentials(config.user, config.password),
connection_attempts=3,
heartbeat_interval=60,
))
def get_channel():
config = ConfigParser()
config.read("python/configs/config.ini")
connection = BlockingConnection(
ConnectionParameters(host=config.get("RABBIT", "host"),
port=config.get("RABBIT", "port"),
credentials=PlainCredentials(
username=config.get("RABBIT", "user"),
password=config.get("RABBIT", "pass")),
heartbeat=0))
channel = connection.channel(1)
channel.basic_qos(prefetch_count=1)
return channel
def create_publisher(host, port, username, password, exchange, exchange_type,
durable, auto_delete, routing_key):
credentials = None
if username and password:
credentials = PlainCredentials(username, password)
return RabbitMQPublisher(
host=host,
port=port,
credentials=credentials,
exchange=exchange,
routing_key=routing_key,
exchange_type=exchange_type,
durable=durable,
auto_delete=auto_delete
)
def make_node(connection_params=None, name=None, timeout=None):
"""
Blocking construction and connection of node.
@param connection_params AMQP connection parameters. By default, uses CFG.server.amqp (most common use).
"""
log.debug("In make_node")
node = NodeB()
connection_params = connection_params or CFG.server.amqp
credentials = PlainCredentials(connection_params["username"], connection_params["password"])
conn_parameters = ConnectionParameters(host=connection_params["host"], virtual_host=connection_params["vhost"], port=connection_params["port"], credentials=credentials)
connection = PyonSelectConnection(conn_parameters , node.on_connection_open)
ioloop_process = gevent.spawn(ioloop, connection, name=name)
#ioloop_process = gevent.spawn(connection.ioloop.start)
node.ready.wait(timeout=timeout)
return node, ioloop_process
def __init__(self, state):
self.state = state
credentials = PlainCredentials(
RabbitMQConfiguration().getRabbitMQProperty(
"gameLogicServerUserName"),
RabbitMQConfiguration().getRabbitMQProperty(
"gameLogicServerUserName"))
parameters = pika.ConnectionParameters(
host=RabbitMQConfiguration().getRabbitMQProperty(
"gameLogicServerBrokerHost"),
virtual_host=self.state.vhost,
credentials=credentials)
# instantiate a connection
logging.debug("GameLogicServer] WorkerChannel - Starting a connection")
self.connection = pika.BlockingConnection(parameters=parameters)
logging.debug("GameLogicServer] WorkerChannel - Creating a channel")
self.channel = self.connection.channel()
def check_integration(status):
"""
Check the Integration MQ status
:param status:
:return:
"""
conn = pika.BlockingConnection(
pika.ConnectionParameters(
host="ec2-18-197-180-1.eu-central-1.compute.amazonaws.com",
virtual_host="vhost",
credentials=PlainCredentials("rabbitmq", "rabbitmq")
)
)
channel = conn.channel()
status['mq-integration'] = channel.is_open
def __init__(self):
self.uptime = 0
self.index_count = 0
self.connection = pika.BlockingConnection(
pika.ConnectionParameters(
host='localhost',
port=5672,
credentials=PlainCredentials(username='******',
password='******')))
self.channel = self.connection.channel()
self.channel.queue_declare(queue='ipfs', durable=True)
logging.info("Attached to queue ipfs")
self.cache = redis.Redis(host='localhost', port=6379, db=10)
logging.info("Connected to Redis")
def send_message(host, port, vhost, username, password, exchange, routing_key, queue, topic_type, message):
connection = pika.BlockingConnection(pika.ConnectionParameters(
host=host,
port=int(port),
virtual_host=vhost,
credentials=PlainCredentials(username, password)
))
channel = connection.channel()
if queue is not None and topic_type is not None:
channel.exchange_declare(exchange=exchange,exchange_type=topic_type)
channel.queue_declare(queue=queue, durable=True)
channel.queue_bind(queue=queue, exchange=exchange, routing_key=routing_key)
channel.basic_publish(exchange=exchange, routing_key=routing_key, body=message,
properties=pika.BasicProperties(delivery_mode=2))
time.sleep(2)
connection.close()
logging.info("Message published to: " + exchange + "/" + routing_key)
def start(self):
# parameters require for the AMQP connection: user name and password...
credentials = PlainCredentials(
RabbitMQConfiguration().getRabbitMQProperty(
"gameLogicServerUserName"),
RabbitMQConfiguration().getRabbitMQProperty(
"gameLogicServerUserName"))
parameters = pika.ConnectionParameters(
host=RabbitMQConfiguration().getRabbitMQProperty(
"gameLogicServerBrokerHost"),
virtual_host=self.state.vhost,
credentials=credentials)
# instantiate a connection
connection = SelectConnection(parameters=parameters,
on_open_callback=self.on_connected)
# required behavior on close
connection.add_on_close_callback(self.on_close)
# start the connection
connection.ioloop.start()
def setup(self):
if self.username and self.password:
credentials = PlainCredentials(username=self.username, password=self.password)
connection_params = pika.ConnectionParameters(host=self.host, credentials=credentials)
else:
connection_params = pika.ConnectionParameters(host=self.host)
self.conn = pika.BlockingConnection(connection_params)
self.channel = self.conn.channel()
self.channel.basic_qos(prefetch_count=1)
# Setup Qs for listening
for queue in self.queues:
self.channel.queue_declare(queue=queue, durable=True)
def callback(ch, method, properties, body):
self._dispatch_trigger(ch, method, properties, body, queue)
self.channel.basic_consume(callback, queue=queue)
def __init__(self, host, port, username, password, exchange, topic_type,
queue, routing_key):
logging.info("Connecting to Rabbit MQ")
self.connection = pika.BlockingConnection(
pika.ConnectionParameters(host=host,
port=port,
credentials=PlainCredentials(
username, password)))
self.exchange = exchange
self.routing_key = routing_key
logging.info("Initiating Channel")
self.connection_attempts = 50
self.retry_delay = 10000
self.channel = self.connection.channel()
self.channel.exchange_declare(exchange=exchange, type=topic_type)
self.channel.queue_declare(queue=queue)
self.channel.queue_bind(queue=queue,
exchange=exchange,
routing_key=routing_key)
def createLoggingServer(gameName, instanceName):
logging.info("GameLogicServer] Creating Logging server for " + gameName +
" " + instanceName)
vhost = RabbitMQConfiguration().getRabbitMQProperty(
"virtualHostSeparator") + gameName + RabbitMQConfiguration(
).getRabbitMQProperty("virtualHostSeparator") + instanceName
credentials = PlainCredentials(
RabbitMQConfiguration().getRabbitMQProperty("loggingServerUserName"),
RabbitMQConfiguration().getRabbitMQProperty("loggingServerUserName"))
parameters = pika.ConnectionParameters(
host=RabbitMQConfiguration().getRabbitMQProperty(
"gameLogicServerBrokerHost"),
virtual_host=vhost,
credentials=credentials)
logging.debug("LoggingServer] Starting a connection")
connection = pika.BlockingConnection(parameters=parameters)
logging.debug("LoggingServer] Creating a channel")
channel = connection.channel()
logging.debug(
"LoggingServer] Declaring a queue " +
RabbitMQConfiguration().getRabbitMQProperty("loggingServerQueueName"))
channel.queue_declare(queue=RabbitMQConfiguration().getRabbitMQProperty(
"loggingServerQueueName"),
exclusive=False,
durable=True)
logging.debug(
"LoggingServer] Binding the queue with the rooting key " +
RabbitMQConfiguration().getRabbitMQProperty("loggingServerBindingKey"))
channel.queue_bind(exchange=RabbitMQConfiguration().getRabbitMQProperty(
"gameLogicServerExchangeName"),
queue=RabbitMQConfiguration().getRabbitMQProperty(
"loggingServerQueueName"),
routing_key=RabbitMQConfiguration().getRabbitMQProperty(
"loggingServerBindingKey"))
channel.basic_consume(consumer_callback=handle_delivery_loggingserver,
queue=RabbitMQConfiguration().getRabbitMQProperty(
"loggingServerQueueName"),
no_ack=True)
logging.info(" LoggingServer] Waiting for messages on " + vhost)
channel.start_consuming()
logging.info("LoggingServer] Process terminated")
def __init__(self,
host,
port=5672,
user_name="admin",
password="******",
connection_attempts=3,
heartbeat_interval=60 * 60,
channel_max=200,
virtual_host="/",
ssl=False):
"""
connect to rabbit mq
:param str host: Hostname or IP Address to connect to
:param int port: TCP port to connect to
:param str user_name: default is guest
:param str password: default is guest
:param int connection_attempts: Maximum number of retry attempts
:param int heartbeat_interval: How often to send heartbeats.
Min between this value and server's proposal
will be used. Use 0 to deactivate heartbeats
and None to accept server's proposal.
:param int channel_max: Maximum number of channels to allow
:param str virtual_host: RabbitMQ virtual host to use
:param bool ssl: Enable SSL
:return:
"""
self.host = host
self.port = port
self.connection_attempts = connection_attempts
self.channel_max = channel_max
self.heartbeat_interval = heartbeat_interval
self.credentials = PlainCredentials(username=user_name,
password=password)
self.virtual_host = virtual_host
self.ssl = ssl
self.__connection = self.__connection_rabbit()
self.__channel_single = self.__connection.channel()
self.__channel_work_queue = self.__connection.channel()
self.__channel_subscribe = self.__connection.channel()
self.__channel_routing = self.__connection.channel()
self.__channel_topics = self.__connection.channel()
def _amqp_conn_params(self):
vhost = self.def_amqp.virtual_host if 'virtual_host' in self.def_amqp else self.def_amqp.vhost
if 'credentials' in self.def_amqp:
username = self.def_amqp.credentials.username
password = self.def_amqp.credentials.password
else:
username = self.def_amqp.username
password = self.def_amqp.password
params = ConnectionParameters(self.def_amqp.host,
int(self.def_amqp.port),
vhost,
PlainCredentials(username, password),
frame_max=int(self.def_amqp.frame_max))
# heartbeat is an integer but ConnectionParameter.__init__ insists it
# be a boolean.
params.heartbeat = float(self.def_amqp.heartbeat)
return params
def check_mq(url, user, pw):
"""
Check status of MQ server
:param url:
:return:
"""
ret = {}
conn = pika.BlockingConnection(
pika.ConnectionParameters(
host=url,
virtual_host="vhost",
credentials=PlainCredentials("rabbitmq", "rabbitmq")
)
)
channel = conn.channel()
ret['up'] = channel.is_open
ret['waiting_count'] = channel.get_waiting_message_count()
return ret
def connecter(self):
self._cnmaria = None
self._cnmaria = mysql.connector.connect(user='******', password='******',
host='192.168.1.28',
database='lectmeteo',
autocommit=True)
credentials = PlainCredentials(
'cuisine',
'jojCUSH1956o',
erase_on_connect=True
)
self._connectionmq = pika.BlockingConnection(
pika.ConnectionParameters(
host='192.168.1.28',
port=5671,
credentials=credentials,
ssl=True # Mettre SSL lorsque ca fonctionnera avec RabbitMQ
)
)
self._channel = self._connectionmq.channel()
def init_app(self,
app: Flask,
use_ssl: bool = False,
body_parser: Callable = None):
self.app = app
self.config = app.config
self.exchange_name = os.getenv('MQ_EXCHANGE')
self.body_parser = body_parser
self.getConnection = lambda: BlockingConnection(
ConnectionParameters(
host=os.getenv('MQ_HOST'),
port=os.getenv('MQ_PORT'),
credentials=PlainCredentials(username=os.getenv('MQ_USER'),
password=os.getenv('MQ_PASS')),
ssl_options=SSLOptions(ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)),
heartbeat=300,
blocked_connection_timeout=150))
# Run every consumer queue
for consumer in self.consumers:
consumer()
def __init__(self, config: ConsumerConfig):
super(PlayConsumer, self).__init__(
ConnectionParameters(
host=config.host,
port=config.port,
credentials=PlainCredentials(config.user, config.password),
connection_attempts=3,
heartbeat_interval=60,
))
self.result_dir = config.result_dir
self.game_args = GameArgs()
self.game_args.game_type = config.game_type
self.game_args.game_speed = config.game_speed
self.game_args.timeout = config.timeout
self.game_args.bot_dir = config.bot_dir
self.game_args.game_dir = config.game_dir
self.game_args.map_dir = config.map_dir
self.game_args.bwapi_data_bwta_dir = config.bwapi_data_bwta_dir
self.game_args.bwapi_data_bwta2_dir = config.bwapi_data_bwta2_dir
self.game_args.read_overwrite = config.read_overwrite
self.game_args.docker_image = config.docker_image
self.game_args.random_names = config.random_names
self.game_args.opt = config.opt
self.game_args.human = False
self.game_args.headless = True
self.game_args.vnc_host = "localhost"
self.game_args.vnc_base_port = 5900
self.game_args.allow_input = False
self.game_args.auto_launch = False
self.game_args.plot_realtime = False
self.game_args.hide_names = False
self.game_args.capture_movement = False
self.game_args.show_all = False
def make_node(connection_params=None, name=None, timeout=None):
"""
Blocking construction and connection of node.
@param connection_params AMQP connection parameters. By default, uses CFG.server.amqp (most common use).
@return tuple of node and ioloop greenlet
"""
log.debug("In make_node")
node = NodeB()
connection_params = connection_params or CFG.get_safe("server.amqp")
credentials = PlainCredentials(connection_params["username"],
connection_params["password"])
conn_parameters = ConnectionParameters(
host=connection_params["host"],
virtual_host=connection_params["vhost"],
port=connection_params["port"],
credentials=credentials)
connection = PyonSelectConnection(conn_parameters, node.on_connection_open)
ioloop_gl = gevent.spawn(ioloop, connection, name=name)
ioloop_gl._glname = "ScionCC AMQP ioloop"
node.ready.wait(timeout=timeout)
return node, ioloop_gl
