def loadbalancer_update(conf, lb_id, values):
session = get_session(conf)
with session.begin():
lb_ref = loadbalancer_get(conf, lb_id, session=session)
lb_ref.update(values)
lb_ref["updated_at"] = datetime.datetime.utcnow()
return lb_ref
def loadbalancer_create(conf, values):
session = get_session(conf)
with session.begin():
lb_ref = models.LoadBalancer()
lb_ref.update(values)
session.add(lb_ref)
return lb_ref
def lb_count_active_by_device(conf, device_id):
session = get_session(conf)
with session.begin():
lbs_count = (
session.query(models.LoadBalancer).filter_by(device_id=device_id).filter_by(status=lb_status.ACTIVE).count()
)
return lbs_count
def loadbalancer_get_all_by_device_id(conf, device_id):
session = get_session(conf)
query = session.query(models.LoadBalancer).filter_by(device_id=device_id)
lb_refs = query.all()
if not lb_refs:
raise exception.LoadBalancerNotFound("No loadbalancer " "for the device %s found" % device_id)
return lb_refs
def predictor_create(conf, values):
session = get_session(conf)
with session.begin():
predictor_ref = models.Predictor()
predictor_ref.update(values)
session.add(predictor_ref)
return predictor_ref
def device_create(conf, values):
session = get_session(conf)
with session.begin():
device_ref = models.Device()
device_ref.update(values)
session.add(device_ref)
return device_ref
def serverfarm_create(conf, values):
session = get_session(conf)
with session.begin():
serverfarm_ref = models.ServerFarm()
serverfarm_ref.update(values)
session.add(serverfarm_ref)
return serverfarm_ref
def virtualserver_create(conf, values):
session = get_session(conf)
with session.begin():
vserver_ref = models.VirtualServer()
vserver_ref.update(values)
session.add(vserver_ref)
return vserver_ref
def sticky_create(conf, values):
session = get_session(conf)
with session.begin():
sticky_ref = models.Sticky()
sticky_ref.update(values)
session.add(sticky_ref)
return sticky_ref
def server_get_by_address_on_device(conf, server_address, device_id):
session = get_session(conf)
server_refs = session.query(models.Server).filter_by(address=server_address).filter_by(deployed="True")
for server_ref in server_refs:
sf = serverfarm_get(conf, server_ref["sf_id"], session=session)
lb = loadbalancer_get(conf, sf["lb_id"])
if device_id == lb["device_id"]:
return server_ref
raise exception.ServerNotFound(server_address=server_address, device_id=device_id)
def loadbalancer_get(conf, loadbalancer_id, tenant_id=None, session=None):
session = session or get_session(conf)
query = session.query(models.LoadBalancer).filter_by(id=loadbalancer_id)
if tenant_id:
query = query.filter_by(tenant_id=tenant_id)
loadbalancer_ref = query.first()
if not loadbalancer_ref:
raise exception.LoadBalancerNotFound(loadbalancer_id=loadbalancer_id)
return loadbalancer_ref
def loadbalancer_get_all_by_vm_id(conf, tenant_id, vm_id):
session = get_session(conf)
query = (
session.query(models.LoadBalancer)
.distinct()
.filter_by(tenant_id=tenant_id)
.filter(models.LoadBalancer.id == models.ServerFarm.lb_id)
.filter(models.Server.sf_id == models.ServerFarm.id)
.filter(models.Server.vm_id == vm_id)
)
return query.all()
def probe_get(conf, probe_id, tenant_id=None, session=None):
session = session or get_session(conf)
query = session.query(models.Probe).filter_by(id=probe_id)
if tenant_id:
query = (
query.filter(models.Probe.sf_id == models.ServerFarm.id)
.filter(models.LoadBalancer.id == models.ServerFarm.lb_id)
.filter(models.LoadBalancer.tenant_id == tenant_id)
)
probe_ref = query.first()
if not probe_ref:
raise exception.ProbeNotFound(probe_id=probe_id)
return probe_ref
def virtualserver_get_all_by_lb_id(conf, lb_id, tenant_id=None):
session = get_session(conf)
query = (
session.query(models.VirtualServer)
.filter(models.ServerFarm.lb_id == lb_id)
.filter_by(sf_id=models.ServerFarm.id)
)
if tenant_id:
query = query.filter(models.LoadBalancer.id == models.ServerFarm.lb_id).filter(
models.LoadBalancer.tenant_id == tenant_id
)
vips = query.all()
return vips
def virtualserver_get(conf, vserver_id, tenant_id=None, session=None):
session = session or get_session(conf)
query = session.query(models.VirtualServer).filter_by(id=vserver_id)
if tenant_id:
query = (
query.filter(models.VirtualServer.sf_id == models.ServerFarm.id)
.filter(models.LoadBalancer.id == models.ServerFarm.lb_id)
.filter(models.LoadBalancer.tenant_id == tenant_id)
)
vserver_ref = query.first()
if not vserver_ref:
raise exception.VirtualServerNotFound(virtualserver_id=vserver_id)
return vserver_ref
def sticky_get(conf, sticky_id, tenant_id=None, session=None):
session = session or get_session(conf)
query = session.query(models.Sticky).filter_by(id=sticky_id)
if tenant_id:
query = (
query.filter(models.Sticky.sf_id == models.ServerFarm.id)
.filter(models.LoadBalancer.id == models.ServerFarm.lb_id)
.filter(models.LoadBalancer.tenant_id == tenant_id)
)
sticky_ref = query.first()
if not sticky_ref:
raise exception.StickyNotFound(sticky_id=sticky_id)
return sticky_ref
def server_get(conf, server_id, lb_id=None, tenant_id=None, session=None):
session = session or get_session(conf)
query = session.query(models.Server).filter_by(id=server_id)
if lb_id:
query = query.filter(models.ServerFarm.lb_id == lb_id).filter(models.Server.sf_id == models.ServerFarm.id)
if tenant_id:
query = query.filter(models.LoadBalancer.id == lb_id).filter(models.LoadBalancer.tenant_id == tenant_id)
elif tenant_id:
query = (
query.filter(models.Server.sf_id == models.ServerFarm.id)
.filter(models.LoadBalancer.id == models.ServerFarm.lb_id)
.filter(models.LoadBalancer.tenant_id == tenant_id)
)
server_ref = query.first()
if not server_ref:
raise exception.ServerNotFound(server_id=server_id)
return server_ref
def predictor_destroy_by_sf_id(conf, sf_id, session=None):
session = session or get_session(conf)
with session.begin():
session.query(models.Predictor).filter_by(sf_id=sf_id).delete()
def device_get_all(conf):
session = get_session(conf)
query = session.query(models.Device)
return query.all()
def device_get(conf, device_id, session=None):
session = session or get_session(conf)
device_ref = session.query(models.Device).filter_by(id=device_id).first()
if not device_ref:
raise exception.DeviceNotFound(device_id=device_id)
return device_ref
def virtualserver_destroy_by_sf_id(conf, sf_id, session=None):
session = session or get_session(conf)
with session.begin():
session.query(models.VirtualServer).filter_by(sf_id=sf_id).delete()
def virtualserver_destroy(conf, vserver_id):
session = get_session(conf)
with session.begin():
vserver_ref = virtualserver_get(conf, vserver_id, session=session)
session.delete(vserver_ref)
def virtualserver_update(conf, vserver_id, values):
session = get_session(conf)
with session.begin():
vserver_ref = virtualserver_get(conf, vserver_id, session=session)
vserver_ref.update(values)
return vserver_ref
def virtualserver_get_all_by_sf_id(conf, sf_id):
session = get_session(conf)
query = session.query(models.VirtualServer).filter_by(sf_id=sf_id)
return query.all()
def predictor_destroy(conf, predictor_id):
session = get_session(conf)
with session.begin():
predictor_ref = predictor_get(conf, predictor_id, session=session)
session.delete(predictor_ref)
def predictor_get(conf, predictor_id, session=None):
session = session or get_session(conf)
predictor_ref = session.query(models.Predictor).filter_by(id=predictor_id).first()
if not predictor_ref:
raise exception.PredictorNotFound(predictor_id=predictor_id)
return predictor_ref
def device_update(conf, device_id, values):
session = get_session(conf)
with session.begin():
device_ref = device_get(conf, device_id, session=session)
device_ref.update(values)
return device_ref
def predictor_get_by_sf_id(conf, sf_id):
session = get_session(conf)
predictor_ref = session.query(models.Predictor).filter_by(sf_id=sf_id).first()
if not predictor_ref:
raise exception.PredictorNotFound(sf_id=sf_id)
return predictor_ref
def device_destroy(conf, device_id):
session = get_session(conf)
with session.begin():
device_ref = device_get(conf, device_id, session=session)
session.delete(device_ref)
def predictor_update(conf, predictor_id, values):
session = get_session(conf)
with session.begin():
predictor_ref = predictor_get(conf, predictor_id, session=session)
predictor_ref.update(values)
return predictor_ref
