def start(self):
# Connect to rabbitmq for config update notifications
rabbitmq_qname = self._service_id
self._vnc_amqp = VncAmqpHandle(self._sandesh, self._logger,
self._db_cls, self._reaction_map,
self._service_id, self._rabbitmq_cfg)
self._vnc_amqp.establish()
cassandra_credential = {
'username': self._cassandra_cfg['user'],
'password': self._cassandra_cfg['password']
}
if not all(cassandra_credential.values()):
cassandra_credential = None
try:
self._vnc_db = VncObjectDBClient(self._cassandra_cfg['servers'],
self._cassandra_cfg['cluster_id'],
logger=self._logger.log,
credential=cassandra_credential)
except Exception as e:
template = 'Exception {0} connecting to Config DB. Arguments:\n{1!r}'
msg = template.format(type(e).__name__, e.args)
self._logger.error('%s: %s' % (msg, traceback.format_exc()))
exit()
self._db_cls.init(self, self._logger, self._vnc_db)
self._sync_config_db()
def __init__(self, args=None):
self._args = args
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
self._disc = client.DiscoveryClient(
self._args.disc_server_ip,
self._args.disc_server_port,
ModuleNames[Module.SVC_MONITOR])
# initialize logger
self.logger = ServiceMonitorLogger(self._disc, args)
# rotating log file for catchall errors
self._err_file = self._args.trace_file
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
try:
with open(self._err_file, 'a'):
handler = logging.handlers.RotatingFileHandler(
self._err_file, maxBytes=64*1024, backupCount=2)
self._svc_err_logger.addHandler(handler)
except IOError:
self.logger.warning("Failed to open trace file %s" %
self._err_file)
# init object_db
self._object_db = ServiceMonitorDB(self._args, self.logger)
DBBaseSM.init(self, self.logger, self._object_db)
# init rabbit connection
self.rabbit = VncAmqpHandle(self.logger, DBBaseSM,
REACTION_MAP, 'svc_monitor', args=self._args)
self.rabbit.establish()
def __init__(self, sm_logger=None, args=None):
self._args = args
self._args.analytics_api_ssl_params = analytics_api_ssl_params(args)
# initialize logger
if sm_logger is not None:
self.logger = sm_logger
else:
# Initialize logger
self.logger = ServiceMonitorLogger(args)
# init object_db
self._object_db = ServiceMonitorDB(self._args, self.logger)
DBBaseSM.init(self, self.logger, self._object_db)
# init rabbit connection
rabbitmq_cfg = get_rabbitmq_cfg(args)
if 'host_ip' in self._args:
host_ip = self._args.host_ip
else:
host_ip = socket.gethostbyname(socket.getfqdn())
self.rabbit = VncAmqpHandle(self.logger._sandesh, self.logger,
DBBaseSM, REACTION_MAP, 'svc_monitor',
rabbitmq_cfg, host_ip,
self._args.trace_file)
self.rabbit.establish()
def __init__(self, sm_logger=None, args=None):
self._args = args
# initialize logger
if sm_logger is not None:
self.logger = sm_logger
else:
# Initialize logger
self.logger = ServiceMonitorLogger(args)
# rotating log file for catchall errors
self._err_file = self._args.trace_file
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
try:
with open(self._err_file, 'a'):
handler = logging.handlers.RotatingFileHandler(self._err_file,
maxBytes=64 *
1024,
backupCount=2)
self._svc_err_logger.addHandler(handler)
except IOError:
self.logger.warning("Failed to open trace file %s" %
self._err_file)
# init object_db
self._object_db = ServiceMonitorDB(self._args, self.logger)
DBBaseSM.init(self, self.logger, self._object_db)
# init rabbit connection
self.rabbit = VncAmqpHandle(self.logger,
DBBaseSM,
REACTION_MAP,
'svc_monitor',
args=self._args)
self.rabbit.establish()
def test_close(self):
vnc = VncAmqpHandle(*(7 * [mock.MagicMock()]))
# Should not raise anything
vnc.close()
# Pretends call of establish()
vnc._vnc_kombu = mock.MagicMock()
vnc.close()
vnc._vnc_kombu.shutdown.assert_called_once_with()
def main(args_str=None,
kube_api_skip=False,
event_queue=None,
vnc_kubernetes_config_dict=None):
_zookeeper_client = None
args = kube_args.parse_args(args_str)
client_pfx = ''
zk_path_pfx = ''
if args.cluster_id:
client_pfx += args.cluster_id + '-'
zk_path_pfx += args.cluster_id + '/'
client_pfx += args.cluster_name + '-'
zk_path_pfx += args.cluster_name + '/'
# randomize collector list
args.random_collectors = args.collectors
if args.collectors:
args.random_collectors = random.sample(args.collectors,
len(args.collectors))
km_logger = common_logger.KubeManagerLogger(args, http_server_port=-1)
if args.nested_mode == '0':
# Initialize AMQP handler then close it to be sure remain queue of a
# precedent run is cleaned
rabbitmq_cfg = kube_args.rabbitmq_args(args)
try:
vnc_amqp = VncAmqpHandle(km_logger._sandesh, km_logger,
config_db.DBBaseKM,
reaction_map.REACTION_MAP,
client_pfx + 'kube_manager', rabbitmq_cfg,
args.host_ip)
vnc_amqp.establish()
vnc_amqp.close()
except Exception: # FIXME: Except clause is too broad
pass
finally:
km_logger.debug("Removed remained AMQP queue")
# Ensure zookeeper is up and running before starting kube-manager
_zookeeper_client = ZookeeperClient(client_pfx + "kube-manager",
args.zk_server_ip, args.host_ip)
km_logger.notice("Waiting to be elected as master...")
_zookeeper_client.master_election(zk_path_pfx + "kube-manager",
os.getpid(), run_kube_manager,
km_logger, args, kube_api_skip,
event_queue,
vnc_kubernetes_config_dict)
else: # nested mode, skip zookeeper mastership check
run_kube_manager(km_logger, args, kube_api_skip, event_queue,
vnc_kubernetes_config_dict)
def __init__(self, args=None, logger=None, q=None, kube=None):
self.args = args
self.logger = logger
self.q = q
self.kube = kube
# init vnc connection
self.vnc_lib = self._vnc_connect()
# init access to db
self._db = db.KubeNetworkManagerDB(self.args, self.logger)
DBBaseKM.init(self, self.logger, self._db)
# init rabbit connection
self.rabbit = VncAmqpHandle(self.logger,
DBBaseKM,
REACTION_MAP,
'kube_manager',
args=self.args)
self.rabbit.establish()
# sync api server db in local cache
self._sync_km()
self.rabbit._db_resync_done.set()
# provision cluster
self._provision_cluster()
# handle events
self.label_cache = label_cache.LabelCache()
self.namespace_mgr = importutils.import_object(
'kube_manager.vnc.vnc_namespace.VncNamespace',
vnc_lib=self.vnc_lib,
cluster_pod_subnets=self.args.pod_subnets)
self.service_mgr = importutils.import_object(
'kube_manager.vnc.vnc_service.VncService', self.vnc_lib,
self.label_cache, self.args, self.logger, self.kube)
self.network_policy_mgr = importutils.import_object(
'kube_manager.vnc.vnc_network_policy.VncNetworkPolicy',
self.vnc_lib, self.label_cache, self.logger)
self.pod_mgr = importutils.import_object(
'kube_manager.vnc.vnc_pod.VncPod',
self.vnc_lib,
self.label_cache,
self.service_mgr,
self.network_policy_mgr,
self.q,
svc_fip_pool=self._get_cluster_service_fip_pool())
self.endpoints_mgr = importutils.import_object(
'kube_manager.vnc.vnc_endpoints.VncEndpoints', self.vnc_lib,
self.logger, self.kube)
self.ingress_mgr = importutils.import_object(
'kube_manager.vnc.vnc_ingress.VncIngress', self.args, self.vnc_lib,
self.label_cache, self.logger, self.kube)
def __init__(self, sm_logger=None, args=None):
self._args = args
# initialize discovery client
self._disc = None
if self._args.disc_server_ip and self._args.disc_server_port:
dss_kwargs = {}
if self._args.disc_server_ssl:
if self._args.disc_server_cert:
dss_kwargs.update({'cert': self._args.disc_server_cert})
if self._args.disc_server_key:
dss_kwargs.update({'key': self._args.disc_server_key})
if self._args.disc_server_cacert:
dss_kwargs.update(
{'cacert': self._args.disc_server_cacert})
self._disc = client.DiscoveryClient(
self._args.disc_server_ip, self._args.disc_server_port,
ModuleNames[Module.SVC_MONITOR], **dss_kwargs)
# initialize logger
if sm_logger is not None:
self.logger = sm_logger
else:
# Initialize logger
self.logger = ServiceMonitorLogger(self._disc, args)
# rotating log file for catchall errors
self._err_file = self._args.trace_file
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
try:
with open(self._err_file, 'a'):
handler = logging.handlers.RotatingFileHandler(self._err_file,
maxBytes=64 *
1024,
backupCount=2)
self._svc_err_logger.addHandler(handler)
except IOError:
self.logger.warning("Failed to open trace file %s" %
self._err_file)
# init cassandra
self._cassandra = ServiceMonitorDB(self._args, self.logger)
DBBaseSM.init(self, self.logger, self._cassandra)
# init rabbit connection
self.rabbit = VncAmqpHandle(self.logger,
DBBaseSM,
REACTION_MAP,
'svc_monitor',
args=self._args)
self.rabbit.establish()
def main(args_str=None, kube_api_skip=False, event_queue=None):
_zookeeper_client = None
args = kube_args.parse_args(args_str)
if 'kube_timer_interval' not in args:
args.kube_timer_interval = '60'
if args.cluster_id:
client_pfx = args.cluster_id + '-'
zk_path_pfx = args.cluster_id + '/'
else:
client_pfx = ''
zk_path_pfx = ''
# randomize collector list
args.random_collectors = args.collectors
if args.collectors:
args.random_collectors = random.sample(args.collectors,
len(args.collectors))
km_logger = logger.KubeManagerLogger(args)
if args.nested_mode == '0':
# Initialize AMQP handler then close it to be sure remain queue of a
# precedent run is cleaned
rabbitmq_cfg = kube_args.rabbitmq_args(args)
try:
vnc_amqp = VncAmqpHandle(km_logger._sandesh, km_logger, DBBaseKM,
REACTION_MAP, 'kube_manager',
rabbitmq_cfg)
vnc_amqp.establish()
vnc_amqp.close()
except Exception:
pass
finally:
km_logger.debug("Removed remained AMQP queue")
# Ensure zookeeper is up and running before starting kube-manager
_zookeeper_client = ZookeeperClient(client_pfx + "kube-manager",
args.zk_server_ip)
km_logger.notice("Waiting to be elected as master...")
_zookeeper_client.master_election(zk_path_pfx + "/kube-manager",
os.getpid(), run_kube_manager,
km_logger, args, kube_api_skip,
event_queue)
km_logger.notice("Elected master kube-manager node. Initializing...")
else: #nested mode, skip zookeeper mastership check
run_kube_manager(km_logger, args, kube_api_skip, event_queue)
def main(args_str=None):
global _zookeeper_client
if not args_str:
args_str = ' '.join(sys.argv[1:])
args = parse_args(args_str)
if args.cluster_id:
client_pfx = args.cluster_id + '-'
zk_path_pfx = args.cluster_id + '/'
else:
client_pfx = ''
zk_path_pfx = ''
# initialize discovery client
discovery_client = None
if args.disc_server_ip and args.disc_server_port:
dss_kwargs = {}
if args.disc_server_ssl:
if args.disc_server_cert:
dss_kwargs.update({'cert': args.disc_server_cert})
if args.disc_server_key:
dss_kwargs.update({'key': args.disc_server_key})
if args.disc_server_cacert:
dss_kwargs.update({'cacert': args.disc_server_cacert})
discovery_client = client.DiscoveryClient(
args.disc_server_ip, args.disc_server_port,
ModuleNames[Module.SVC_MONITOR], **dss_kwargs)
# Initialize logger
sm_logger = ServiceMonitorLogger(discovery_client,
args,
http_server_port=-1)
# Initialize AMQP handler then close it to be sure remain queue of a
# precedent run is cleaned
vnc_amqp = VncAmqpHandle(sm_logger,
DBBaseSM,
REACTION_MAP,
'svc_monitor',
args=args)
vnc_amqp.establish()
vnc_amqp.close()
sm_logger.debug("Removed remained AMQP queue")
# Waiting to be elected as master node
_zookeeper_client = ZookeeperClient(client_pfx + "svc-monitor",
args.zk_server_ip)
sm_logger.notice("Waiting to be elected as master...")
_zookeeper_client.master_election(zk_path_pfx + "/svc-monitor",
os.getpid(), run_svc_monitor, sm_logger,
args)
def main(args_str=None):
global _zookeeper_client
if not args_str:
args_str = ' '.join(sys.argv[1:])
args = parse_args(args_str)
if args.cluster_id:
client_pfx = args.cluster_id + '-'
zk_path_pfx = args.cluster_id + '/'
else:
client_pfx = ''
zk_path_pfx = ''
# randomize collector list
args.random_collectors = args.collectors
if args.collectors:
args.random_collectors = random.sample(args.collectors,
len(args.collectors))
# Initialize logger without introspect thread
sm_logger = ServiceMonitorLogger(args, http_server_port=-1)
# Initialize AMQP handler then close it to be sure remain queue of a
# precedent run is cleaned
try:
vnc_amqp = VncAmqpHandle(sm_logger,
DBBaseSM,
REACTION_MAP,
'svc_monitor',
args=args)
vnc_amqp.establish()
vnc_amqp.close()
except Exception:
pass
finally:
sm_logger.debug("Removed remained AMQP queue")
# Waiting to be elected as master node
_zookeeper_client = ZookeeperClient(client_pfx + "svc-monitor",
args.zk_server_ip)
sm_logger.notice("Waiting to be elected as master...")
_zookeeper_client.master_election(zk_path_pfx + "/svc-monitor",
os.getpid(), run_svc_monitor, sm_logger,
args)
def start(self):
# Connect to rabbitmq for config update notifications
rabbitmq_qname = self._service_id
self._vnc_amqp = VncAmqpHandle(self._sandesh, self._logger,
self._db_cls, self._reaction_map,
self._service_id, self._rabbitmq_cfg)
self._vnc_amqp.establish()
cassandra_credential = {
'username': self._cassandra_cfg['user'],
'password': self._cassandra_cfg['password']
}
if not all(cassandra_credential.values()):
cassandra_credential = None
self._vnc_db = VncObjectDBClient(self._cassandra_cfg['servers'],
self._cassandra_cfg['cluster_id'],
logger=self._logger.log,
credential=cassandra_credential)
self._db_cls.init(self, self._logger, self._vnc_db)
self._sync_config_db()
def __init__(self, args=None, logger=None):
self.args = args
self.logger = logger
# init vnc connection
self.vnc_lib = self._vnc_connect()
# init access to db
self._db = db.MesosNetworkManagerDB(self.args, self.logger)
DBBaseMM.init(self, self.logger, self._db)
# init rabbit connection
self.rabbit = VncAmqpHandle(self.logger, DBBaseMM, REACTION_MAP,
'mesos_manager', args=self.args)
self.rabbit.establish()
# sync api server db in local cache
self._sync_sm()
self.rabbit._db_resync_done.set()
def __init__(self, sm_logger=None, args=None):
self._args = args
# initialize logger
if sm_logger is not None:
self.logger = sm_logger
else:
# Initialize logger
self.logger = ServiceMonitorLogger(args)
# init object_db
self._object_db = ServiceMonitorDB(self._args, self.logger)
DBBaseSM.init(self, self.logger, self._object_db)
# init rabbit connection
rabbitmq_cfg = get_rabbitmq_cfg(args)
self.rabbit = VncAmqpHandle(self.logger._sandesh, self.logger,
DBBaseSM, REACTION_MAP, 'svc_monitor',
rabbitmq_cfg, self._args.trace_file)
self.rabbit.establish()
def __init__(self,
args=None,
logger=None,
q=None,
kube=None,
vnc_kubernetes_config_dict=None):
self._name = type(self).__name__
self.args = args
self.logger = logger
self.q = q
self.kube = kube
self._cluster_pod_ipam_fq_name = None
self._cluster_service_ipam_fq_name = None
self._cluster_ip_fabric_ipam_fq_name = None
# init vnc connection
self.vnc_lib = self._vnc_connect()
# Cache common config.
self.vnc_kube_config = vnc_kube_config(logger=self.logger,
vnc_lib=self.vnc_lib,
args=self.args,
queue=self.q,
kube=self.kube)
#
# In nested mode, kube-manager connects to contrail components running
# in underlay via global link local services. TCP flows established on
# link local services will be torn down by vrouter, if there is no
# activity for configured(or default) timeout. So disable flow timeout
# on these connections, so these flows will persist.
#
# Note: The way to disable flow timeout is to set timeout to max
# possible value.
#
if self.args.nested_mode == '1':
for cassandra_server in self.args.cassandra_server_list:
cassandra_port = cassandra_server.split(':')[-1]
flow_aging_manager.create_flow_aging_timeout_entry(
self.vnc_lib, "tcp", cassandra_port, 2147483647)
if self.args.rabbit_port:
flow_aging_manager.create_flow_aging_timeout_entry(
self.vnc_lib, "tcp", self.args.rabbit_port, 2147483647)
if self.args.vnc_endpoint_port:
flow_aging_manager.create_flow_aging_timeout_entry(
self.vnc_lib, "tcp", self.args.vnc_endpoint_port,
2147483647)
for collector in self.args.collectors:
collector_port = collector.split(':')[-1]
flow_aging_manager.create_flow_aging_timeout_entry(
self.vnc_lib, "tcp", collector_port, 2147483647)
# init access to db
self._db = db.KubeNetworkManagerDB(self.args, self.logger)
DBBaseKM.init(self, self.logger, self._db)
# If nested mode is enabled via config, then record the directive.
if self.args.nested_mode == '1':
DBBaseKM.set_nested(True)
# sync api server db in local cache
self._sync_km()
# init rabbit connection
rabbitmq_cfg = kube_args.rabbitmq_args(self.args)
self.rabbit = VncAmqpHandle(
self.logger._sandesh, self.logger, DBBaseKM,
reaction_map.REACTION_MAP, self.args.cluster_id + '-' +
self.args.cluster_name + '-kube_manager', rabbitmq_cfg,
self.args.host_ip)
self.rabbit.establish()
self.rabbit._db_resync_done.set()
# Register label add and delete callbacks with label management entity.
label_cache.XLabelCache.register_label_add_callback(
VncKubernetes.create_tags)
label_cache.XLabelCache.register_label_delete_callback(
VncKubernetes.delete_tags)
# Instantiate and init Security Policy Manager.
self.security_policy_mgr = VncSecurityPolicy(self.vnc_lib,
VncKubernetes.get_tags)
# provision cluster
self._provision_cluster()
if vnc_kubernetes_config_dict:
self.vnc_kube_config.update(**vnc_kubernetes_config_dict)
else:
# Update common config.
self.vnc_kube_config.update(
cluster_pod_ipam_fq_name=self._get_cluster_pod_ipam_fq_name(),
cluster_service_ipam_fq_name=self.
_get_cluster_service_ipam_fq_name(),
cluster_ip_fabric_ipam_fq_name=self.
_get_cluster_ip_fabric_ipam_fq_name())
# handle events
self.label_cache = label_cache.LabelCache()
self.vnc_kube_config.update(label_cache=self.label_cache)
self.tags_mgr = importutils.import_object(
'kube_manager.vnc.vnc_tags.VncTags')
self.network_policy_mgr = importutils.import_object(
'kube_manager.vnc.vnc_network_policy.VncNetworkPolicy')
self.namespace_mgr = importutils.import_object(
'kube_manager.vnc.vnc_namespace.VncNamespace',
self.network_policy_mgr)
self.ingress_mgr = importutils.import_object(
'kube_manager.vnc.vnc_ingress.VncIngress', self.tags_mgr)
self.service_mgr = importutils.import_object(
'kube_manager.vnc.vnc_service.VncService', self.ingress_mgr)
self.pod_mgr = importutils.import_object(
'kube_manager.vnc.vnc_pod.VncPod', self.service_mgr,
self.network_policy_mgr)
self.endpoints_mgr = importutils.import_object(
'kube_manager.vnc.vnc_endpoints.VncEndpoints')
self.network_mgr = importutils.import_object(
'kube_manager.vnc.vnc_network.VncNetwork')
# Create system default security policies.
VncSecurityPolicy.create_deny_all_security_policy()
VncSecurityPolicy.create_allow_all_security_policy()
self.ingress_mgr.create_ingress_security_policy()
VncKubernetes._vnc_kubernetes = self
# Associate cluster with the APS.
VncSecurityPolicy.tag_cluster_application_policy_set()
def __init__(self, args=None, logger=None, q=None, kube=None):
self._name = type(self).__name__
self.args = args
self.logger = logger
self.q = q
self.kube = kube
self._cluster_pod_ipam_fq_name = None
# init vnc connection
self.vnc_lib = self._vnc_connect()
# HACK ALERT.
# Till we have an alternate means to get config objects, we will
# direcly connect to cassandra. Such a persistant connection is
# discouraged, but is the only option we have for now.
#
# Disable flow timeout on this connection, so the flow persists.
#
if self.args.nested_mode is '1':
for cassandra_server in self.args.cassandra_server_list:
cassandra_port = cassandra_server.split(':')[-1]
flow_aging_manager.create_flow_aging_timeout_entry(
self.vnc_lib, "tcp", cassandra_port, 2147483647)
# init access to db
self._db = db.KubeNetworkManagerDB(self.args, self.logger)
DBBaseKM.init(self, self.logger, self._db)
# If nested mode is enabled via config, then record the directive.
if self.args.nested_mode is '1':
DBBaseKM.set_nested(True)
# init rabbit connection
self.rabbit = VncAmqpHandle(self.logger,
DBBaseKM,
REACTION_MAP,
'kube_manager',
args=self.args)
self.rabbit.establish()
# Cache common config.
self.vnc_kube_config = vnc_kube_config(logger=self.logger,
vnc_lib=self.vnc_lib,
args=self.args,
queue=self.q,
kube=self.kube)
# sync api server db in local cache
self._sync_km()
self.rabbit._db_resync_done.set()
# provision cluster
self._provision_cluster()
# handle events
self.label_cache = label_cache.LabelCache()
# Update common config.
self.vnc_kube_config.update(
label_cache=self.label_cache,
cluster_pod_ipam_fq_name=self._get_cluster_pod_ipam_fq_name(),
cluster_service_fip_pool=self._get_cluster_service_fip_pool())
self.network_policy_mgr = importutils.import_object(
'kube_manager.vnc.vnc_network_policy.VncNetworkPolicy')
self.namespace_mgr = importutils.import_object(
'kube_manager.vnc.vnc_namespace.VncNamespace',
self.network_policy_mgr)
self.ingress_mgr = importutils.import_object(
'kube_manager.vnc.vnc_ingress.VncIngress')
self.service_mgr = importutils.import_object(
'kube_manager.vnc.vnc_service.VncService', self.ingress_mgr)
self.pod_mgr = importutils.import_object(
'kube_manager.vnc.vnc_pod.VncPod', self.service_mgr,
self.network_policy_mgr)
self.endpoints_mgr = importutils.import_object(
'kube_manager.vnc.vnc_endpoints.VncEndpoints')
VncKubernetes._vnc_kubernetes = self
def __init__(self, args=None, logger=None, q=None, kube=None):
self._name = type(self).__name__
self.args = args
self.logger = logger
self.q = q
self.kube = kube
self._cluster_pod_ipam_fq_name = None
# init vnc connection
self.vnc_lib = self._vnc_connect()
# init access to db
self._db = db.KubeNetworkManagerDB(self.args, self.logger)
DBBaseKM.init(self, self.logger, self._db)
# If nested mode is enabled via config, then record the directive.
if self.args.nested_mode is '1':
DBBaseKM.set_nested(True)
# init rabbit connection
self.rabbit = VncAmqpHandle(self.logger,
DBBaseKM,
REACTION_MAP,
'kube_manager',
args=self.args)
self.rabbit.establish()
# Cache common config.
self.vnc_kube_config = vnc_kube_config(logger=self.logger,
vnc_lib=self.vnc_lib,
args=self.args,
queue=self.q,
kube=self.kube)
# sync api server db in local cache
self._sync_km()
self.rabbit._db_resync_done.set()
# provision cluster
self._provision_cluster()
# handle events
self.label_cache = label_cache.LabelCache()
# Update common config.
self.vnc_kube_config.update(
label_cache=self.label_cache,
cluster_pod_ipam_fq_name=self._get_cluster_pod_ipam_fq_name(),
cluster_service_fip_pool=self._get_cluster_service_fip_pool())
self.network_policy_mgr = importutils.import_object(
'kube_manager.vnc.vnc_network_policy.VncNetworkPolicy')
self.namespace_mgr = importutils.import_object(
'kube_manager.vnc.vnc_namespace.VncNamespace',
self.network_policy_mgr)
self.service_mgr = importutils.import_object(
'kube_manager.vnc.vnc_service.VncService')
self.pod_mgr = importutils.import_object(
'kube_manager.vnc.vnc_pod.VncPod', self.service_mgr,
self.network_policy_mgr)
self.endpoints_mgr = importutils.import_object(
'kube_manager.vnc.vnc_endpoints.VncEndpoints')
self.ingress_mgr = importutils.import_object(
'kube_manager.vnc.vnc_ingress.VncIngress')
def __init__(self,
args=None,
logger=None,
q=None,
kube=None,
vnc_kubernetes_config_dict=None):
self._name = type(self).__name__
self.args = args
self.logger = logger
self.q = q
self.kube = kube
self._cluster_pod_ipam_fq_name = None
self._cluster_service_ipam_fq_name = None
self._cluster_ip_fabric_ipam_fq_name = None
# init vnc connection
self.vnc_lib = self._vnc_connect()
# Cache common config.
self.vnc_kube_config = vnc_kube_config(logger=self.logger,
vnc_lib=self.vnc_lib,
args=self.args,
queue=self.q,
kube=self.kube)
# HACK ALERT.
# Till we have an alternate means to get config objects, we will
# direcly connect to cassandra and rabbitmq. Such a persistant connection
# is discouraged, but is the only option we have for now.
#
# Disable flow timeout on this connection, so the flow persists.
#
if self.args.nested_mode is '1':
for cassandra_server in self.args.cassandra_server_list:
cassandra_port = cassandra_server.split(':')[-1]
flow_aging_manager.create_flow_aging_timeout_entry(
self.vnc_lib, "tcp", cassandra_port, 2147483647)
if self.args.rabbit_port:
flow_aging_manager.create_flow_aging_timeout_entry(
self.vnc_lib, "tcp", self.args.rabbit_port, 2147483647)
# init access to db
self._db = db.KubeNetworkManagerDB(self.args, self.logger)
DBBaseKM.init(self, self.logger, self._db)
# If nested mode is enabled via config, then record the directive.
if self.args.nested_mode is '1':
DBBaseKM.set_nested(True)
# sync api server db in local cache
self._sync_km()
# init rabbit connection
rabbitmq_cfg = kube_args.rabbitmq_args(self.args)
self.rabbit = VncAmqpHandle(self.logger._sandesh, self.logger,
DBBaseKM, REACTION_MAP, 'kube_manager',
rabbitmq_cfg)
self.rabbit.establish()
self.rabbit._db_resync_done.set()
# Register label add and delete callbacks with label management entity.
XLabelCache.register_label_add_callback(VncKubernetes.create_tags)
XLabelCache.register_label_delete_callback(VncKubernetes.delete_tags)
# Instantiate and init Security Policy Manager.
self.security_policy_mgr = VncSecurityPolicy(self.vnc_lib,
VncKubernetes.get_tags)
# provision cluster
self._provision_cluster()
if vnc_kubernetes_config_dict:
self.vnc_kube_config.update(**vnc_kubernetes_config_dict)
else:
# Update common config.
self.vnc_kube_config.update(
cluster_pod_ipam_fq_name=self._get_cluster_pod_ipam_fq_name(),
cluster_service_ipam_fq_name=self.
_get_cluster_service_ipam_fq_name(),
cluster_ip_fabric_ipam_fq_name=self.
_get_cluster_ip_fabric_ipam_fq_name())
# handle events
self.label_cache = label_cache.LabelCache()
self.vnc_kube_config.update(label_cache=self.label_cache)
self.network_policy_mgr = importutils.import_object(
'kube_manager.vnc.vnc_network_policy.VncNetworkPolicy')
self.namespace_mgr = importutils.import_object(
'kube_manager.vnc.vnc_namespace.VncNamespace',
self.network_policy_mgr)
self.ingress_mgr = importutils.import_object(
'kube_manager.vnc.vnc_ingress.VncIngress')
self.service_mgr = importutils.import_object(
'kube_manager.vnc.vnc_service.VncService', self.ingress_mgr)
self.pod_mgr = importutils.import_object(
'kube_manager.vnc.vnc_pod.VncPod', self.service_mgr,
self.network_policy_mgr)
self.endpoints_mgr = importutils.import_object(
'kube_manager.vnc.vnc_endpoints.VncEndpoints')
self.tags_mgr = importutils.import_object(
'kube_manager.vnc.vnc_tags.VncTags')
# Create system default security policies.
VncSecurityPolicy.create_deny_all_security_policy()
VncSecurityPolicy.create_allow_all_security_policy()
self.ingress_mgr.create_ingress_security_policy()
VncKubernetes._vnc_kubernetes = self
# Associate cluster with the APS.
VncSecurityPolicy.tag_cluster_application_policy_set()