def __init__(self):
self._loadbalancer_repo = f5_repos.LoadBalancerRepository()
self._esd = esd_repo.EsdRepository()
self._amphora_repo = repo.AmphoraRepository()
self._health_mon_repo = repo.HealthMonitorRepository()
self._lb_repo = repo.LoadBalancerRepository()
self._listener_repo = repo.ListenerRepository()
self._member_repo = repo.MemberRepository()
self._pool_repo = f5_repos.PoolRepository()
self._l7policy_repo = f5_repos.L7PolicyRepository()
self._l7rule_repo = repo.L7RuleRepository()
self._flavor_repo = repo.FlavorRepository()
self._vip_repo = repo.VipRepository()
self.bigip = BigipAS3RestClient(
bigip_urls=CONF.f5_agent.bigip_urls,
enable_verify=CONF.f5_agent.bigip_verify,
enable_token=CONF.f5_agent.bigip_token,
esd=self._esd)
self.network_driver = driver_utils.get_network_driver()
self.cert_manager = cert_manager.CertManagerWrapper()
self.status = status.StatusManager(self.bigip)
worker = periodics.PeriodicWorker([(self.pending_sync, None, None)])
t = threading.Thread(target=worker.start)
t.daemon = True
t.start()
if cfg.CONF.f5_agent.prometheus:
prometheus_port = CONF.f5_agent.prometheus_port
LOG.info('Starting Prometheus HTTP server on port {}'.format(
prometheus_port))
prometheus.start_http_server(prometheus_port)
super(ControllerWorker, self).__init__()
def _get_server(self, loadbalancer_id):
""" Get scheduled host of the loadbalancer.
:param loadbalancer_id: loadbalancer id
:return: scheduled host
"""
loadbalancer = self.repositories.load_balancer.get(
db_apis.get_session(), id=loadbalancer_id)
if loadbalancer.server_group_id:
return loadbalancer.server_group_id
else:
# fetch scheduled server from VIP port
network_driver = driver_utils.get_network_driver()
return network_driver.get_scheduled_host(loadbalancer.vip_port_id)
def loadbalancer_create(self, loadbalancer):
if loadbalancer.flavor == driver_dm.Unset:
loadbalancer.flavor = None
network_driver = driver_utils.get_network_driver()
host = network_driver.get_scheduled_host(loadbalancer.vip_port_id)
LOG.info("Scheduling loadbalancer %s to %s",
loadbalancer.loadbalancer_id, host)
payload = {
consts.LOAD_BALANCER_ID: loadbalancer.loadbalancer_id,
consts.FLAVOR: loadbalancer.flavor
}
client = self.client.prepare(server=host)
client.cast({}, 'create_load_balancer', **payload)
def __init__(self):
self._repositories = repo.Repositories()
self._loadbalancer_repo = f5_repos.LoadBalancerRepository()
self._amphora_repo = repo.AmphoraRepository()
self._health_mon_repo = repo.HealthMonitorRepository()
self._listener_repo = f5_repos.ListenerRepository()
self._member_repo = repo.MemberRepository()
self._pool_repo = f5_repos.PoolRepository()
self._l7policy_repo = f5_repos.L7PolicyRepository()
self._l7rule_repo = repo.L7RuleRepository()
self._vip_repo = repo.VipRepository()
self._quota_repo = repo.QuotasRepository()
self.status = status_manager.StatusManager()
self.sync = sync_manager.SyncManager(self.status,
self._loadbalancer_repo)
self.network_driver = driver_utils.get_network_driver()
self.queue = SetQueue()
worker = periodics.PeriodicWorker([
(self.pending_sync, None, None),
(self.full_sync_reappearing_devices, None, None),
(self.cleanup_orphaned_tenants, None, None)
])
t = threading.Thread(target=worker.start)
t.daemon = True
t.start()
LOG.info("Starting as3worker")
as3worker = threading.Thread(target=self.as3worker)
as3worker.setDaemon(True)
as3worker.start()
if cfg.CONF.f5_agent.prometheus:
prometheus_port = CONF.f5_agent.prometheus_port
LOG.info('Starting Prometheus HTTP server on port {}'.format(
prometheus_port))
prometheus.start_http_server(prometheus_port)
super(ControllerWorker, self).__init__()
def __init__(self, status_manager):
self._esd_repo = esd_repo.EsdRepository()
self._network_driver = driver_utils.get_network_driver()
self._cert_manager = cert_manager.CertManagerWrapper()
self._status_manager = status_manager