class RabbitmqLayerTestCaseMixin(object):
"""
TestCase mixin for Django tests.
Allow to test your channels project against real broker. Provide
isolated virtual host for each test.
"""
local = False
def _pre_setup(self):
"""Create RabbitMQ virtual host."""
if ChannelTestCaseMixin in self.__class__.__mro__:
raise ImproperlyConfigured(
'ChannelTestCase is not allowed as base class for '
'RabbitmqLayerTestCaseMixin')
hostname = environ.get('RABBITMQ_HOST', 'localhost')
port = environ.get('RABBITMQ_PORT', '5672')
user = environ.get('RABBITMQ_USER', 'guest')
password = environ.get('RABBITMQ_PASSWORD', 'guest')
management_port = environ.get('RABBITMQ_MANAGEMENT_PORT', '15672')
management_url = 'http://%s:%s' % (hostname, management_port)
self.virtual_host = ''.join(choice(ascii_letters) for i in range(8))
self.amqp_url = 'amqp://%s:%s/%s' % (hostname, port, self.virtual_host)
self.management = AdminAPI(management_url, (user, password))
self.management.create_vhost(self.virtual_host)
self.management.create_user_permission(user, self.virtual_host)
if self.local:
layer_class_name = 'asgi_rabbitmq.RabbitmqLocalChannelLayer'
else:
layer_class_name = 'asgi_rabbitmq.RabbitmqChannelLayer'
self._overridden_settings = {
'CHANNEL_LAYERS': {
'default': {
'BACKEND': layer_class_name,
'ROUTING': settings.CHANNEL_LAYERS['default']['ROUTING'],
'CONFIG': settings.CHANNEL_LAYERS['default']['CONFIG'],
'TEST_CONFIG': {
'url': self.amqp_url,
},
},
},
}
self._self_overridden_context = override_settings(
**self._overridden_settings)
self._self_overridden_context.enable()
super(RabbitmqLayerTestCaseMixin, self)._pre_setup()
def _post_teardown(self):
"""Remove RabbitMQ virtual host."""
super(RabbitmqLayerTestCaseMixin, self)._post_teardown()
self._self_overridden_context.disable()
delattr(self, '_self_overridden_context')
self._overridden_settings = None
self.management.delete_vhost(self.virtual_host)
del self.virtual_host
del self.amqp_url
del self.management
def connect_mqtt(self, virtual_host, queue_name):
try:
api = AdminAPI(url='http://' + self.rabbitmq_server + ':' +
str(8080),
auth=(self.rabbitmq_id, self.rabbitmq_pwd))
vhosts_info = api.list_vhosts()
vhost_list = [vhost['name'] for vhost in vhosts_info]
if virtual_host not in vhost_list:
api.create_vhost(virtual_host)
api.create_user_permission(name=self.rabbitmq_id,
vhost=virtual_host)
credentials = pika.PlainCredentials(self.rabbitmq_id,
self.rabbitmq_pwd)
params = pika.ConnectionParameters(self.rabbitmq_server,
self.rabbitmq_port,
virtual_host, credentials)
connection = pika.BlockingConnection(params)
self.channel = connection.channel()
except Exception as ex: # 에러 종류
print('RabbitMQ Connect fail', ex) # ex는 발생한 에러의 이름을 받아오는 변수
return False
try:
self.channel.queue_declare(queue=queue_name)
return True
except Exception as ex: # 에러 종류
print('Declare Queue fail', ex) # ex는 발생한 에러의 이름을 받아오는 변수
return False
def initialize_rabbitmq_user(user):
"""
This function is used when a new provider registers in the network.
It adds a new user in RabbitMQ and sets their permissions.
:param user: The newly registered user
"""
# TODO: passwords have a pattern for all users. This needs to be changed.
password = user.username + '_mqtt'
api = AdminAPI(url='http://' + RABBITMQ_HOST + ':' +
RABBITMQ_MANAGEMENT_PORT,
auth=(RABBITMQ_USER, RABBITMQ_PASS))
api.create_user(user.username, password)
# process = subprocess.Popen(['sudo', 'rabbitmqctl', 'add_user', user.username, password],
# stdout=subprocess.PIPE, universal_newlines=True)
# stdout, stderr = process.communicate()
# print(stdout)
permission = "^(" + user.username + ".*|amq.default)$"
api.create_user_permission(user.username, '/', permission, permission,
permission)
class RecSystemsManager:
def __init__(self, host='localhost', username='******', password='******', queuename='testqueue'):
self.api = AdminAPI(url='http://' + host + ':15672', auth=('guest', 'guest'))
self.host = host
self.cr = pika.PlainCredentials(username=username, password=password)
self.conn = pika.BlockingConnection(pika.ConnectionParameters(self.host, credentials=self.cr))
self.chann = self.conn.channel()
self.queue = self.chann.queue_declare(queuename, durable=True)
self.routing_key = queuename
def subscribeSystem(self, teamname, system, passwd):
self.api.create_vhost('second_vhost', tracing=True)
self.api.create_user(teamname, passwd)
self.api.create_user_permission(teamname, 'second_vhost')
# Include SQL Database authentication here
self.chann.queue_declare(teamname + '_' + system + '_' + 'rec_requests', durable=True)
self.chann.queue_declare(teamname + '_' + system + '_' + 'user_assign', durable=True)
self.chann.queue_declare(teamname + '_' + system + '_' + 'news_recs', durable=True)
self.chann.queue_declare(teamname + '_' + system + '_' + 'user_data', durable=True)
self.chann.queue_declare(teamname + '_' + system + '_' + 'news_request', durable=True)
def createQueue(self, name, durable):
self.chann.queue_declare(name, durable)
def create_project_user_and_vhost(project_id):
secrets = get_project_secrets(project_id)
hidden_secrets = get_project_hidden_secrets(project_id)
# connect to RabbitMQ management api
rabbit_api = AdminAPI(url=f'http://carrier-rabbit:15672',
auth=(hidden_secrets["rabbit_user"],
hidden_secrets["rabbit_password"]))
# prepare user credentials
user = f"rabbit_user_{project_id}"
password = password_generator()
vhost = f"project_{project_id}_vhost"
# create project user and vhost
rabbit_api.create_vhost(vhost)
rabbit_api.create_user(user, password)
rabbit_api.create_user_permission(user, vhost)
# set project secrets
secrets["rabbit_project_user"] = user
secrets["rabbit_project_password"] = password
secrets["rabbit_project_vhost"] = vhost
set_project_secrets(project_id, secrets)