def callback(self, cb_func):
self._callback = cb_func
self._rabbit_cfg.update({
"subscribe_cb": self._callback,
"logger": self.logger
})
self._kombu = VncKombuClient(**self._rabbit_cfg)
def start(self):
# Create an instance of issu casandra_config_db_uuid
self.issu_cass_config_db_uuid_handle = ICCassandraClient(
self.old_cassandra.addr_info, self.new_cassandra.addr_info,
self.old_cassandra.user, self.old_cassandra.password,
self.new_cassandra.user, self.new_cassandra.password,
self.old_cassandra.db_prefix, self.new_cassandra.db_prefix,
self.cassandra_issu_info, self.logger)
# Prepare it for Issu
# Establish a amqp connection with newerversion
self.amqp_new_version_handle = VncKombuClient(
self.new_rabbit.amqp_ip, self.new_rabbit.amqp_port,
self.new_rabbit.amqp_user, self.new_rabbit.amqp_pwd,
self.new_rabbit.amqp_vhost, self.new_rabbit.amqp_ha,
self.new_rabbit.amqp_q, self.amqp_callback_handler, self.logger)
# Create a amqp connection with oldversion, passing all the information
self.amqp_old_version_handle = ICKombuClient(
self.old_rabbit.amqp_ip, self.old_rabbit.amqp_port,
self.old_rabbit.amqp_user, self.old_rabbit.amqp_pwd,
self.old_rabbit.amqp_vhost, self.old_rabbit.amqp_ha,
self.old_rabbit.amqp_q, self.issu_amqp_callback_handler,
self.logger, self.issu_cass_config_db_uuid_handle,
self.keyspace_info, self.new_api_info)
def _connect_rabbit(self):
rabbit_server = self._args.rabbit_server
rabbit_port = self._args.rabbit_port
rabbit_user = self._args.rabbit_user
rabbit_password = self._args.rabbit_password
rabbit_vhost = self._args.rabbit_vhost
rabbit_ha_mode = self._args.rabbit_ha_mode
self._db_resync_done = gevent.event.Event()
q_name = 'kube_network_manager.%s' % (socket.gethostname())
self._vnc_kombu = VncKombuClient(
rabbit_server,
rabbit_port,
rabbit_user,
rabbit_password,
rabbit_vhost,
rabbit_ha_mode,
q_name,
self._vnc_subscribe_callback,
self.logger.log,
rabbit_use_ssl=self._args.rabbit_use_ssl,
kombu_ssl_version=self._args.kombu_ssl_version,
kombu_ssl_keyfile=self._args.kombu_ssl_keyfile,
kombu_ssl_certfile=self._args.kombu_ssl_certfile,
kombu_ssl_ca_certs=self._args.kombu_ssl_ca_certs)
def start(self):
# Create an instance of issu casandra_config_db_uuid
self.issu_cass_config_db_uuid_handle = ICCassandraClient(
self.old_cassandra.addr_info, self.new_cassandra.addr_info,
self.old_cassandra.user, self.old_cassandra.password,
self.new_cassandra.user, self.new_cassandra.password,
self.old_cassandra.use_ssl, self.old_cassandra.ca_certs,
self.new_cassandra.use_ssl, self.new_cassandra.ca_certs,
self.old_cassandra.db_prefix, self.new_cassandra.db_prefix,
self.cassandra_issu_info, self.logger)
# Prepare it for Issu
# Establish a amqp connection with newerversion
self.logger("Initiating amqp connection with new server...",
level=SandeshLevel.SYS_DEBUG)
self.logger("Connection settings: %s" % (str(self.new_rabbit)),
level=SandeshLevel.SYS_DEBUG)
self.amqp_new_version_handle = VncKombuClient(
self.new_rabbit.amqp_ip,
self.new_rabbit.amqp_port,
self.new_rabbit.amqp_user,
self.new_rabbit.amqp_pwd,
self.new_rabbit.amqp_vhost,
self.new_rabbit.amqp_ha,
self.new_rabbit.amqp_q,
self.amqp_callback_handler,
self.logger,
rabbit_use_ssl=self.new_rabbit.amqp_use_ssl,
kombu_ssl_version=self.new_rabbit.amqp_ssl_version,
kombu_ssl_keyfile=self.new_rabbit.amqp_ssl_keyfile,
kombu_ssl_certfile=self.new_rabbit.amqp_ssl_certfile,
kombu_ssl_ca_certs=self.new_rabbit.amqp_ssl_ca_certs)
self.logger("amqp connection initiated successfully with new server",
level=SandeshLevel.SYS_DEBUG)
# Create a amqp connection with oldversion, passing all the information
self.logger("Initiating amqp connection with old server...",
level=SandeshLevel.SYS_DEBUG)
self.logger("Connection settings: %s" % (str(self.old_rabbit)),
level=SandeshLevel.SYS_DEBUG)
self.amqp_old_version_handle = ICKombuClient(
self.old_rabbit.amqp_ip,
self.old_rabbit.amqp_port,
self.old_rabbit.amqp_user,
self.old_rabbit.amqp_pwd,
self.old_rabbit.amqp_vhost,
self.old_rabbit.amqp_ha,
self.old_rabbit.amqp_q,
self.issu_amqp_callback_handler,
self.logger,
self.issu_cass_config_db_uuid_handle,
self.keyspace_info,
self.new_api_info,
rabbit_use_ssl=self.old_rabbit.amqp_use_ssl,
kombu_ssl_version=self.old_rabbit.amqp_ssl_version,
kombu_ssl_keyfile=self.old_rabbit.amqp_ssl_keyfile,
kombu_ssl_certfile=self.old_rabbit.amqp_ssl_certfile,
kombu_ssl_ca_certs=self.old_rabbit.amqp_ssl_ca_certs)
self.logger("amqp connection initiated successfully with old server",
level=SandeshLevel.SYS_DEBUG)
def start(self):
# Subscribe for contrail-api service with Discovery
self._discovery_client.subscribe(API_SERVER_DISCOVERY_SERVICE_NAME, 2,
self._apiserver_subscribe_callback)
self._update_apiserver_connection_status('', ConnectionStatus.INIT)
# Connect to rabbitmq for config update notifications
rabbitmq_qname = self._service_id
self._rabbitmq_client = VncKombuClient(
self._rabbitmq_info['servers'], self._rabbitmq_info['port'],
self._rabbitmq_info['user'], self._rabbitmq_info['password'],
self._rabbitmq_info['vhost'], self._rabbitmq_info['ha_mode'],
rabbitmq_qname, self._rabbitmq_subscribe_callback, self._logger)
def establish(self):
q_name = '.'.join([self.q_name_prefix, socket.gethostname()])
self._vnc_kombu = VncKombuClient(
self._rabbitmq_cfg['servers'], self._rabbitmq_cfg['port'],
self._rabbitmq_cfg['user'], self._rabbitmq_cfg['password'],
self._rabbitmq_cfg['vhost'], self._rabbitmq_cfg['ha_mode'],
q_name, self._vnc_subscribe_callback,
self.logger.log, rabbit_use_ssl=self._rabbitmq_cfg['use_ssl'],
kombu_ssl_version=self._rabbitmq_cfg['ssl_version'],
kombu_ssl_keyfile=self._rabbitmq_cfg['ssl_keyfile'],
kombu_ssl_certfile=self._rabbitmq_cfg['ssl_certfile'],
kombu_ssl_ca_certs=self._rabbitmq_cfg['ssl_ca_certs'])
def establish(self):
q_name = '.'.join([self.q_name_prefix, socket.gethostname()])
self._vnc_kombu = VncKombuClient(
self._args.rabbit_server, self._args.rabbit_port,
self._args.rabbit_user, self._args.rabbit_password,
self._args.rabbit_vhost, self._args.rabbit_ha_mode,
q_name, self._vnc_subscribe_callback,
self.logger.log, rabbit_use_ssl=self._args.rabbit_use_ssl,
kombu_ssl_version=self._args.kombu_ssl_version,
kombu_ssl_keyfile=self._args.kombu_ssl_keyfile,
kombu_ssl_certfile=self._args.kombu_ssl_certfile,
kombu_ssl_ca_certs=self._args.kombu_ssl_ca_certs)
def start(self):
# Subscribe for contrail-api service with Discovery
# Connect to rabbitmq for config update notifications
rabbitmq_qname = self._service_id
self._rabbitmq_client = VncKombuClient(self._rabbitmq_info['servers'],
self._rabbitmq_info['port'], self._rabbitmq_info['user'],
self._rabbitmq_info['password'], self._rabbitmq_info['vhost'],
self._rabbitmq_info['ha_mode'], rabbitmq_qname,
self._rabbitmq_subscribe_callback, self._logger,
rabbit_use_ssl=self._rabbitmq_info['use_ssl'],
kombu_ssl_version=self._rabbitmq_info['ssl_version'],
kombu_ssl_keyfile=self._rabbitmq_info['ssl_keyfile'],
kombu_ssl_certfile=self._rabbitmq_info['ssl_certfile'],
kombu_ssl_ca_certs=self._rabbitmq_info['ssl_ca_certs'])
def _connect_rabbit(self):
rabbit_server = self._args.rabbit_server
rabbit_port = self._args.rabbit_port
rabbit_user = self._args.rabbit_user
rabbit_password = self._args.rabbit_password
rabbit_vhost = self._args.rabbit_vhost
rabbit_ha_mode = self._args.rabbit_ha_mode
self._db_resync_done = gevent.event.Event()
q_name = 'svc_mon.%s' % (socket.gethostname())
self._vnc_kombu = VncKombuClient(rabbit_server, rabbit_port,
rabbit_user, rabbit_password,
rabbit_vhost, rabbit_ha_mode,
q_name, self._vnc_subscribe_callback,
self.logger.log)
def start(self):
self._update_apiserver_connection_status('', ConnectionStatus.INIT)
if self._api_servers:
self._api_client_connection_task = gevent.spawn(
self._connect_to_api_server)
# Connect to rabbitmq for config update notifications
rabbitmq_qname = self._service_id
self._rabbitmq_client = VncKombuClient(self._rabbitmq_info['servers'],
self._rabbitmq_info['port'], self._rabbitmq_info['user'],
self._rabbitmq_info['password'], self._rabbitmq_info['vhost'],
self._rabbitmq_info['ha_mode'], rabbitmq_qname,
self._rabbitmq_subscribe_callback, self._logger,
rabbit_use_ssl=self._rabbitmq_info['use_ssl'],
kombu_ssl_version=self._rabbitmq_info['ssl_version'],
kombu_ssl_keyfile=self._rabbitmq_info['ssl_keyfile'],
kombu_ssl_certfile=self._rabbitmq_info['ssl_certfile'],
kombu_ssl_ca_certs=self._rabbitmq_info['ssl_ca_certs'])
def _connect_rabbit(self):
rabbit_server = self._args.rabbit_server
rabbit_port = self._args.rabbit_port
rabbit_user = self._args.rabbit_user
rabbit_password = self._args.rabbit_password
rabbit_vhost = self._args.rabbit_vhost
rabbit_ha_mode = self._args.rabbit_ha_mode
self._db_resync_done = gevent.event.Event()
q_name = 'svc_mon.%s' % (socket.gethostname())
self._vnc_kombu = VncKombuClient(rabbit_server, rabbit_port,
rabbit_user, rabbit_password,
rabbit_vhost, rabbit_ha_mode, q_name,
self._vnc_subscribe_callback,
self.config_log)
cass_server_list = self._args.cassandra_server_list
reset_config = self._args.reset_config
self._cassandra = VncCassandraClient(cass_server_list, reset_config,
self._args.cluster_id, None,
self.config_log)
DBBase.init(self, self.logger, self._cassandra)
def __init__(self, args=None):
self._args = args
self._fabric_rt_inst_obj = None
# 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.SCHEMA_TRANSFORMER])
self._sandesh = Sandesh()
# Reset the sandesh send rate limit value
if args.sandesh_send_rate_limit is not None:
SandeshSystem.set_sandesh_send_rate_limit(
args.sandesh_send_rate_limit)
sandesh.VnList.handle_request = self.sandesh_vn_handle_request
sandesh.RoutintInstanceList.handle_request = \
self.sandesh_ri_handle_request
sandesh.ServiceChainList.handle_request = \
self.sandesh_sc_handle_request
sandesh.StObjectReq.handle_request = \
self.sandesh_st_object_handle_request
module = Module.SCHEMA_TRANSFORMER
module_name = ModuleNames[module]
node_type = Module2NodeType[module]
node_type_name = NodeTypeNames[node_type]
instance_id = INSTANCE_ID_DEFAULT
hostname = socket.gethostname()
self._sandesh.init_generator(
module_name,
hostname,
node_type_name,
instance_id,
self._args.collectors,
'to_bgp_context',
int(args.http_server_port),
['cfgm_common', 'schema_transformer.sandesh'],
self._disc,
logger_class=args.logger_class,
logger_config_file=args.logging_conf)
self._sandesh.set_logging_params(enable_local_log=args.log_local,
category=args.log_category,
level=args.log_level,
file=args.log_file,
enable_syslog=args.use_syslog,
syslog_facility=args.syslog_facility)
ConnectionState.init(
self._sandesh, hostname, module_name, instance_id,
staticmethod(ConnectionState.get_process_state_cb), NodeStatusUVE,
NodeStatus)
self._sandesh.trace_buffer_create(name="MessageBusNotifyTraceBuf",
size=1000)
rabbit_servers = self._args.rabbit_server
rabbit_port = self._args.rabbit_port
rabbit_user = self._args.rabbit_user
rabbit_password = self._args.rabbit_password
rabbit_vhost = self._args.rabbit_vhost
rabbit_ha_mode = self._args.rabbit_ha_mode
self._db_resync_done = gevent.event.Event()
q_name = 'schema_transformer.%s' % (socket.gethostname())
self._vnc_kombu = VncKombuClient(rabbit_servers, rabbit_port,
rabbit_user, rabbit_password,
rabbit_vhost, rabbit_ha_mode, q_name,
self._vnc_subscribe_callback,
self.config_log)
self._cassandra = SchemaTransformerDB(self, _zookeeper_client)
DBBaseST.init(self, self._sandesh.logger(), self._cassandra)
DBBaseST._sandesh = self._sandesh
DBBaseST._vnc_lib = _vnc_lib
ServiceChain.init()
self.reinit()
# create cpu_info object to send periodic updates
sysinfo_req = False
cpu_info = vnc_cpu_info.CpuInfo(module_name, instance_id, sysinfo_req,
self._sandesh, 60)
self._cpu_info = cpu_info
self._db_resync_done.set()
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.DEVICE_MANAGER])
self._sandesh = Sandesh()
module = Module.DEVICE_MANAGER
module_name = ModuleNames[module]
node_type = Module2NodeType[module]
node_type_name = NodeTypeNames[node_type]
instance_id = INSTANCE_ID_DEFAULT
hostname = socket.gethostname()
self._sandesh.init_generator(module_name, hostname, node_type_name,
instance_id, self._args.collectors,
'to_bgp_context',
int(args.http_server_port),
['cfgm_common', 'device_manager.sandesh'],
self._disc)
self._sandesh.set_logging_params(enable_local_log=args.log_local,
category=args.log_category,
level=args.log_level,
file=args.log_file,
enable_syslog=args.use_syslog,
syslog_facility=args.syslog_facility)
ConnectionState.init(
self._sandesh, hostname, module_name, instance_id,
staticmethod(ConnectionState.get_process_state_cb), NodeStatusUVE,
NodeStatus)
# Retry till API server is up
connected = False
self.connection_state_update(ConnectionStatus.INIT)
while not connected:
try:
self._vnc_lib = VncApi(args.admin_user, args.admin_password,
args.admin_tenant_name,
args.api_server_ip,
args.api_server_port)
connected = True
self.connection_state_update(ConnectionStatus.UP)
except requests.exceptions.ConnectionError as e:
# Update connection info
self.connection_state_update(ConnectionStatus.DOWN, str(e))
time.sleep(3)
except ResourceExhaustionError: # haproxy throws 503
time.sleep(3)
rabbit_servers = self._args.rabbit_server
rabbit_port = self._args.rabbit_port
rabbit_user = self._args.rabbit_user
rabbit_password = self._args.rabbit_password
rabbit_vhost = self._args.rabbit_vhost
rabbit_ha_mode = self._args.rabbit_ha_mode
self._db_resync_done = gevent.event.Event()
q_name = 'device_manager.%s' % (socket.gethostname())
self._vnc_kombu = VncKombuClient(rabbit_servers, rabbit_port,
rabbit_user, rabbit_password,
rabbit_vhost, rabbit_ha_mode, q_name,
self._vnc_subscribe_callback,
self.config_log)
cass_server_list = self._args.cassandra_server_list
reset_config = self._args.reset_config
self._cassandra = VncCassandraClient(cass_server_list, reset_config,
self._args.cluster_id, None,
self.config_log)
DBBase.init(self, self._sandesh.logger(), self._cassandra)
ok, global_system_config_list = self._cassandra._cassandra_global_system_config_list(
)
if not ok:
self.config_log('global system config list returned error: %s' %
global_system_config_list)
else:
for fq_name, uuid in global_system_config_list:
GlobalSystemConfigDM.locate(uuid)
ok, vn_list = self._cassandra._cassandra_virtual_network_list()
if not ok:
self.config_log('virtual network list returned error: %s' %
vn_list)
else:
for fq_name, uuid in vn_list:
vn = VirtualNetworkDM.locate(uuid)
if vn is not None and vn.routing_instances is not None:
for ri_id in vn.routing_instances:
ri_obj = RoutingInstanceDM.locate(ri_id)
ok, bgp_list = self._cassandra._cassandra_bgp_router_list()
if not ok:
self.config_log('bgp router list returned error: %s' % bgp_list)
else:
for fq_name, uuid in bgp_list:
BgpRouterDM.locate(uuid)
ok, pr_list = self._cassandra._cassandra_physical_router_list()
if not ok:
self.config_log('physical router list returned error: %s' %
pr_list)
else:
for fq_name, uuid in pr_list:
pr = PhysicalRouterDM.locate(uuid)
if pr.bgp_router:
BgpRouterDM.locate(pr.bgp_router)
li_set = pr.logical_interfaces
for pi_id in pr.physical_interfaces:
pi = PhysicalInterfaceDM.locate(pi_id)
if pi:
li_set |= pi.logical_interfaces
vmi_set = set()
for li_id in li_set:
li = LogicalInterfaceDM.locate(li_id)
if li and li.virtual_machine_interface:
vmi_set |= set([li.virtual_machine_interface])
for vmi_id in vmi_set:
vmi = VirtualMachineInterfaceDM.locate(vmi_id)
for pr in PhysicalRouterDM.values():
pr.push_config()
self._db_resync_done.set()
while 1:
# Just wait indefinitely
time.sleep(5)
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.DEVICE_MANAGER])
PushConfigState.set_repush_interval(int(self._args.repush_interval))
PushConfigState.set_repush_max_interval(int(self._args.repush_max_interval))
PushConfigState.set_push_delay_per_kb(float(self._args.push_delay_per_kb))
PushConfigState.set_push_delay_max(int(self._args.push_delay_max))
PushConfigState.set_push_delay_enable(bool(self._args.push_delay_enable))
self._sandesh = Sandesh()
# Reset the sandesh send rate limit value
if self._args.sandesh_send_rate_limit is not None:
SandeshSystem.set_sandesh_send_rate_limit(
self._args.sandesh_send_rate_limit)
module = Module.DEVICE_MANAGER
module_name = ModuleNames[module]
node_type = Module2NodeType[module]
node_type_name = NodeTypeNames[node_type]
self.table = "ObjectConfigNode"
instance_id = INSTANCE_ID_DEFAULT
hostname = socket.gethostname()
self._sandesh.init_generator(
module_name, hostname, node_type_name, instance_id,
self._args.collectors, 'to_bgp_context',
int(args.http_server_port),
['cfgm_common', 'device_manager.sandesh'], self._disc)
self._sandesh.set_logging_params(enable_local_log=args.log_local,
category=args.log_category,
level=args.log_level,
file=args.log_file,
enable_syslog=args.use_syslog,
syslog_facility=args.syslog_facility)
PhysicalRouterDM._sandesh = self._sandesh
ConnectionState.init(
self._sandesh, hostname, module_name, instance_id,
staticmethod(ConnectionState.get_process_state_cb),
NodeStatusUVE, NodeStatus, self.table)
# Retry till API server is up
connected = False
self.connection_state_update(ConnectionStatus.INIT)
while not connected:
try:
self._vnc_lib = VncApi(
args.admin_user, args.admin_password,
args.admin_tenant_name, args.api_server_ip,
args.api_server_port,
api_server_use_ssl=args.api_server_use_ssl)
connected = True
self.connection_state_update(ConnectionStatus.UP)
except requests.exceptions.ConnectionError as e:
# Update connection info
self.connection_state_update(ConnectionStatus.DOWN, str(e))
time.sleep(3)
except ResourceExhaustionError: # haproxy throws 503
time.sleep(3)
rabbit_servers = self._args.rabbit_server
rabbit_port = self._args.rabbit_port
rabbit_user = self._args.rabbit_user
rabbit_password = self._args.rabbit_password
rabbit_vhost = self._args.rabbit_vhost
rabbit_ha_mode = self._args.rabbit_ha_mode
self._db_resync_done = gevent.event.Event()
q_name = 'device_manager.%s' % (socket.gethostname())
self._vnc_kombu = VncKombuClient(rabbit_servers, rabbit_port,
rabbit_user, rabbit_password,
rabbit_vhost, rabbit_ha_mode,
q_name, self._vnc_subscribe_callback,
self.config_log, rabbit_use_ssl =
self._args.rabbit_use_ssl,
kombu_ssl_version =
self._args.kombu_ssl_version,
kombu_ssl_keyfile =
self._args.kombu_ssl_keyfile,
kombu_ssl_certfile =
self._args.kombu_ssl_certfile,
kombu_ssl_ca_certs =
self._args.kombu_ssl_ca_certs)
self._cassandra = DMCassandraDB.getInstance(self, _zookeeper_client)
DBBaseDM.init(self, self._sandesh.logger(), self._cassandra)
for obj in GlobalSystemConfigDM.list_obj():
GlobalSystemConfigDM.locate(obj['uuid'], obj)
for obj in GlobalVRouterConfigDM.list_obj():
GlobalVRouterConfigDM.locate(obj['uuid'], obj)
for obj in VirtualNetworkDM.list_obj():
vn = VirtualNetworkDM.locate(obj['uuid'], obj)
if vn is not None and vn.routing_instances is not None:
for ri_id in vn.routing_instances:
ri_obj = RoutingInstanceDM.locate(ri_id)
for obj in BgpRouterDM.list_obj():
BgpRouterDM.locate(obj['uuid'], obj)
pr_obj_list = PhysicalRouterDM.list_obj()
pr_uuid_set = set([pr_obj['uuid'] for pr_obj in pr_obj_list])
self._cassandra.handle_pr_deletes(pr_uuid_set)
for obj in PortTupleDM.list_obj():
PortTupleDM.locate(obj['uuid'],obj)
for obj in pr_obj_list:
pr = PhysicalRouterDM.locate(obj['uuid'], obj)
li_set = pr.logical_interfaces
vmi_set = set()
for pi_id in pr.physical_interfaces:
pi = PhysicalInterfaceDM.locate(pi_id)
if pi:
li_set |= pi.logical_interfaces
vmi_set |= pi.virtual_machine_interfaces
for li_id in li_set:
li = LogicalInterfaceDM.locate(li_id)
if li and li.virtual_machine_interface:
vmi_set |= set([li.virtual_machine_interface])
for vmi_id in vmi_set:
vmi = VirtualMachineInterfaceDM.locate(vmi_id)
si_obj_list = ServiceInstanceDM.list_obj()
si_uuid_set = set([si_obj['uuid'] for si_obj in si_obj_list])
self._cassandra.handle_pnf_resource_deletes(si_uuid_set)
for obj in si_obj_list:
ServiceInstanceDM.locate(obj['uuid'], obj)
for obj in InstanceIpDM.list_obj():
InstanceIpDM.locate(obj['uuid'], obj)
for obj in FloatingIpDM.list_obj():
FloatingIpDM.locate(obj['uuid'], obj)
for vn in VirtualNetworkDM.values():
vn.update_instance_ip_map()
for pr in PhysicalRouterDM.values():
pr.set_config_state()
self._db_resync_done.set()
gevent.joinall(self._vnc_kombu.greenlets())
#
#Connect to remote or local rabbitmq cluster to check the connectivity
#
#!/usr/bin/env python
from cfgm_common.vnc_kombu import VncKombuClient
import time
def lognprint(x, level):
print x
def callb(x):
print x
x = VncKombuClient('10.18.12.1:5672,10.18.12.2:5672,10.18.12.4:5672', '5672', 'guest', 'guest', '', False, 'vnc-config.issu-queue', callb, lognprint)
while (1):
time.sleep(1)
print x
