160 lines
5.0 KiB
Python
160 lines
5.0 KiB
Python
"""
|
|
.. module: lemur.listeners.service
|
|
:platform: Unix
|
|
:copyright: (c) 2015 by Netflix Inc., see AUTHORS for more
|
|
:license: Apache, see LICENSE for more details.
|
|
|
|
.. moduleauthor:: Kevin Glisson <kglisson@netflix.com>
|
|
|
|
"""
|
|
from sqlalchemy import func
|
|
|
|
from lemur import database
|
|
|
|
from lemur.exceptions import CertificateUnavailable
|
|
|
|
from lemur.elbs.models import ELB
|
|
from lemur.listeners.models import Listener
|
|
from lemur.elbs import service as elb_service
|
|
from lemur.certificates import service as certificate_service
|
|
|
|
# from lemur.common.services.aws.elb import update_listeners, create_new_listeners, delete_listeners
|
|
|
|
|
|
def verify_attachment(certificate_id, elb_account_number):
|
|
"""
|
|
Ensures that the certificate we want ot attach to our listener is
|
|
in the same account as our listener.
|
|
|
|
:rtype : Certificate
|
|
:param certificate_id:
|
|
:param elb_account_number:
|
|
:return: :raise CertificateUnavailable:
|
|
"""
|
|
cert = certificate_service.get(certificate_id)
|
|
|
|
# we need to ensure that the specified cert is in our account
|
|
for account in cert.accounts:
|
|
if account.account_number == elb_account_number:
|
|
break
|
|
else:
|
|
raise CertificateUnavailable
|
|
return cert
|
|
|
|
|
|
def get(listener_id):
|
|
return database.get(Listener, listener_id)
|
|
|
|
|
|
def create(elb_id, instance_protocol, instance_port, load_balancer_port, load_balancer_protocol, certificate_id=None):
|
|
listener = Listener(elb_id,
|
|
instance_port,
|
|
instance_protocol,
|
|
load_balancer_port,
|
|
load_balancer_protocol
|
|
)
|
|
|
|
elb = elb_service.get(elb_id)
|
|
elb.listeners.append(listener)
|
|
account_number = elb.account.account_number
|
|
|
|
cert = verify_attachment(certificate_id, account_number)
|
|
listener_tuple = (load_balancer_port, instance_port, load_balancer_protocol, cert.get_art(account_number),)
|
|
# create_new_listeners(account_number, elb.region, elb.name, [listener_tuple])
|
|
|
|
return {'message': 'Listener has been created'}
|
|
|
|
|
|
def update(listener_id, **kwargs):
|
|
listener = get(listener_id)
|
|
|
|
# if the lb_port has changed we need to make sure we are deleting
|
|
# the listener on the old port to avoid listener duplication
|
|
ports = []
|
|
if listener.load_balancer_port != kwargs.get('load_balancer_port'):
|
|
ports.append(listener.load_balancer_port)
|
|
else:
|
|
ports.append(kwargs.get('load_balancer_port'))
|
|
|
|
certificate_id = kwargs.get('certificate_id')
|
|
|
|
listener.instance_port = kwargs.get('instance_port')
|
|
listener.instance_protocol = kwargs.get('instance_protocol')
|
|
listener.load_balancer_port = kwargs.get('load_balancer_port')
|
|
listener.load_balancer_protocol = kwargs.get('load_balancer_protocol')
|
|
|
|
elb = listener.elb
|
|
account_number = listener.elb.account.account_number
|
|
|
|
arn = None
|
|
if certificate_id:
|
|
cert = verify_attachment(certificate_id, account_number)
|
|
cert.elb_listeners.append(listener)
|
|
arn = cert.get_arn(account_number)
|
|
|
|
# remove certificate that is no longer wanted
|
|
if listener.certificate and not certificate_id:
|
|
listener.certificate.remove()
|
|
|
|
database.update(listener)
|
|
listener_tuple = (listener.load_balancer_port, listener.instance_port, listener.load_balancer_protocol, arn,)
|
|
# update_listeners(account_number, elb.region, elb.name, [listener_tuple], ports)
|
|
|
|
return {'message': 'Listener has been updated'}
|
|
|
|
|
|
def delete(listener_id):
|
|
# first try to delete the listener in aws
|
|
listener = get(listener_id)
|
|
# delete_listeners(listener.elb.account.account_number, listener.elb.region, listener.elb.name, [listener.load_balancer_port])
|
|
# cleanup operation in lemur
|
|
database.delete(listener)
|
|
|
|
|
|
def render(args):
|
|
query = database.session_query(Listener)
|
|
|
|
sort_by = args.pop('sort_by')
|
|
sort_dir = args.pop('sort_dir')
|
|
page = args.pop('page')
|
|
count = args.pop('count')
|
|
filt = args.pop('filter')
|
|
certificate_id = args.pop('certificate_id', None)
|
|
elb_id = args.pop('elb_id', None)
|
|
|
|
if certificate_id:
|
|
query = database.get_all(Listener, certificate_id, field='certificate_id')
|
|
|
|
if elb_id:
|
|
query = query.filter(Listener.elb_id == elb_id)
|
|
|
|
if filt:
|
|
terms = filt.split(';')
|
|
query = database.filter(query, Listener, terms)
|
|
|
|
query = database.find_all(query, Listener, args)
|
|
|
|
if sort_by and sort_dir:
|
|
query = database.sort(query, Listener, sort_by, sort_dir)
|
|
|
|
return database.paginate(query, page, count)
|
|
|
|
|
|
def stats(**kwargs):
|
|
attr = getattr(Listener, kwargs.get('metric'))
|
|
query = database.db.session.query(attr, func.count(attr))
|
|
query = query.join(Listener.elb)
|
|
|
|
if kwargs.get('account_id'):
|
|
query = query.filter(ELB.account_id == kwargs.get('account_id'))
|
|
|
|
if kwargs.get('active') == 'true':
|
|
query = query.filter(Listener.certificate_id != None) # noqa
|
|
|
|
items = query.group_by(attr).all()
|
|
results = []
|
|
for key, count in items:
|
|
if key:
|
|
results.append({"key": key, "y": count})
|
|
return results
|