def main(args_str=None):
global _zookeeper_client
global transformer
if not args_str:
args_str = ' '.join(sys.argv[1:])
args = parse_args(args_str)
args._args_list = 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
st_logger = SchemaTransformerLogger(args, http_server_port=-1)
# Initialize AMQP handler then close it to be sure remain queue of a
# precedent run is cleaned
vnc_amqp = STAmqpHandle(st_logger, SchemaTransformer.REACTION_MAP, args)
vnc_amqp.establish()
vnc_amqp.close()
st_logger.debug("Removed remained AMQP queue")
# Waiting to be elected as master node
if 'host_ip' in args:
host_ip = args.host_ip
else:
host_ip = socket.gethostbyname(socket.getfqdn())
if args.zookeeper_ssl_enable:
_zookeeper_client = ZookeeperClient(
client_pfx + "schema",
args.zk_server_ip,
host_ip,
zk_timeout=args.zk_timeout,
zk_ssl_enable=args.zookeeper_ssl_enable,
zk_ssl_keyfile=args.zookeeper_ssl_keyfile,
zk_ssl_certificate=args.zookeeper_ssl_certificate,
zk_ssl_ca_cert=args.zookeeper_ssl_ca_cert)
else:
_zookeeper_client = ZookeeperClient(client_pfx + "schema",
args.zk_server_ip,
host_ip,
zk_timeout=args.zk_timeout)
st_logger.notice("Waiting to be elected as master...")
try:
_zookeeper_client.master_election(zk_path_pfx + "/schema-transformer",
os.getpid(), run_schema_transformer,
st_logger, args)
finally:
if transformer:
transformer.destroy_instance()
def main(args_str=None):
global _amqp_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))
args.log_level = str(args.log_level)
if 'host_ip' not in args:
args.host_ip = socket.gethostbyname(socket.getfqdn())
gevent.signal(signal.SIGHUP, sighup_handler)
gevent.signal(signal.SIGTERM, sigterm_handler)
gevent.signal(signal.SIGINT, sigterm_handler)
if args.dm_run_mode == 'Full':
dm_logger = DeviceManagerLogger(args, http_server_port=-1)
run_job_ztp_manager(dm_logger, args)
dm_logger.notice("Process %s prepared to run in Full mode..." %
os.getpid())
run_device_manager(dm_logger, args)
elif args.dm_run_mode == 'Partial':
dm_logger = DeviceManagerLogger(args, http_server_port=-1)
dm_logger.notice("Process %s prepared to run in Partial mode..." %
os.getpid())
run_job_ztp_manager(dm_logger, args)
else:
if args.zookeeper_ssl_enable:
_zookeeper_client = ZookeeperClient(
client_pfx + "device-manager", args.zk_server_ip, args.host_ip,
args.zookeeper_ssl_enable, args.zookeeper_ssl_keyfile,
args.zookeeper_ssl_certificate, args.zookeeper_ssl_ca_cert)
else:
_zookeeper_client = ZookeeperClient(client_pfx + "device-manager",
args.zk_server_ip,
args.host_ip)
pid = os.getpid()
run_partial_dm(pid)
_zookeeper_client.master_election(zk_path_pfx + "/device-manager",
os.getpid(), run_full_dm, pid)
def issu_zk_start(self):
# Connect to old and new ZK servers
self._zk_old = ZookeeperClient("zk issu client older version",
self._Old_ZK_Version_Address,
self._New_ZK_Version_Address)
self._zk_old.set_lost_cb(self.issu_restart)
self._zk_old.set_suspend_cb(self.issu_restart)
self._zk_new = ZookeeperClient("zk issu client newer version",
self._New_ZK_Version_Address,
self._New_ZK_Version_Address)
self._zk_new.set_lost_cb(self.issu_restart)
self._zk_new.set_suspend_cb(self.issu_restart)
old_prefix = self._Old_Prefix + "/"
new_prefix = self._New_Prefix + "/"
# Delete all state in new ZK if any
if self._zk_new.exists(new_prefix):
children = self._zk_new.get_children(new_prefix)
for _path in children:
if _path in self._Znode_Issu_List:
self._logger(
"Issu contrail zookeeper ,issu_zk_start, deleted paths"
+ str((new_prefix + str(_path))),
level=SandeshLevel.SYS_INFO,
)
self._zk_new.delete_node((new_prefix + str(_path)), True)
else:
continue;
else:
self._zk_new.create_node(new_prefix, "")
if self._zk_old.exists(old_prefix):
children = self._zk_old.get_children(old_prefix)
elif self._zk_old.exists(self._Old_Prefix):
children = self._zk_old.get_children(self._Old_Prefix)
old_prefix = self._Old_Prefix
for _path in children:
# Ignore zookeeper replication
if _path in self._Znode_Issu_List:
new_path = new_prefix + str(_path)
old_path = old_prefix + str(_path)
time.sleep(1)
self._zk_copy(old_path, new_path)
else:
continue
self.issu_compare(new_prefix, old_prefix)
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
dm_logger = DeviceManagerLogger(args, http_server_port=-1)
# Initialize AMQP handler then close it to be sure remain queue of a
# precedent run is cleaned
vnc_amqp = DMAmqpHandle(dm_logger, DeviceManager.REACTION_MAP, args)
vnc_amqp.establish()
vnc_amqp.close()
dm_logger.debug("Removed remained AMQP queue")
_zookeeper_client = ZookeeperClient(client_pfx + "device-manager",
args.zk_server_ip)
dm_logger.notice("Waiting to be elected as master...")
_zookeeper_client.master_election(zk_path_pfx + "/device-manager",
os.getpid(), run_device_manager,
dm_logger, args)
def main(args_str=None):
if not args_str:
args_str = ' '.join(sys.argv[1:])
args = parse_args(args_str)
_disc_service = ZookeeperClient("svc-monitor", args.zk_server_ip)
_disc_service.master_election("/svc-monitor", os.getpid(),
run_svc_monitor, args)
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 initialize_zookeeper_client(args):
if 'host_ip' in args:
host_ip = args.host_ip
else:
host_ip = socket.gethostbyname(socket.getfqdn())
if args.cluster_id:
client_pfx = args.cluster_id + '-'
else:
client_pfx = ''
if args.zookeeper_ssl_enable:
zookeeper_client = ZookeeperClient(client_pfx + "job-manager",
args.zk_server_ip, host_ip,
args.zookeeper_ssl_enable,
args.zookeeper_ssl_keyfile,
args.zookeeper_ssl_certificate,
args.zookeeper_ssl_ca_cert)
else:
zookeeper_client = ZookeeperClient(client_pfx + "job-manager",
args.zk_server_ip, host_ip)
return zookeeper_client
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.SCHEMA_TRANSFORMER], **dss_kwargs)
# Initialize logger
st_logger = SchemaTransformerLogger(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 = STAmqpHandle(st_logger, SchemaTransformer.REACTION_MAP, args)
vnc_amqp.establish()
vnc_amqp.close()
st_logger.debug("Removed remained AMQP queue")
# Waiting to be elected as master node
_zookeeper_client = ZookeeperClient(client_pfx + "schema",
args.zk_server_ip,
zk_timeout=args.zk_timeout)
st_logger.notice(
"Zookeeper client created ip:{}, name:{}, zk_timeout:{}".format(
args.zk_server_ip, client_pfx + "schema", args.zk_timeout))
st_logger.notice("Waiting to be elected as master...")
_zookeeper_client.master_election(zk_path_pfx + "/schema-transformer",
os.getpid(), run_schema_transformer,
st_logger, args)
st_logger.notice("############## SCHEMA_TRANSFORMER STARTED")
def initialize_zookeeper_client(args):
if 'host_ip' in args:
host_ip = args.host_ip
else:
host_ip = socket.gethostbyname(socket.getfqdn())
if args.cluster_id:
client_pfx = args.cluster_id + '-'
else:
client_pfx = ''
zookeeper_client = ZookeeperClient(client_pfx + "job-manager",
args.zk_server_ip, host_ip)
return zookeeper_client
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 = ''
# 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.DEVICE_MANAGER], **dss_kwargs)
# Initialize logger
module = Module.DEVICE_MANAGER
module_pkg = "device_manager"
dm_logger = ConfigServiceLogger(discovery_client,
module,
module_pkg,
args,
http_server_port=-1)
# Initialize AMQP handler then close it to be sure remain queue of a
# precedent run is cleaned
vnc_amqp = DMAmqpHandle(dm_logger, DeviceManager.REACTION_MAP, args)
vnc_amqp.establish()
vnc_amqp.close()
dm_logger.debug("Removed remained AMQP queue")
_zookeeper_client = ZookeeperClient(client_pfx + "device-manager",
args.zk_server_ip)
dm_logger.notice("Waiting to be elected as master...")
_zookeeper_client.master_election(zk_path_pfx + "/device-manager",
os.getpid(), run_device_manager,
dm_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 = ''
_zookeeper_client = ZookeeperClient(client_pfx + "device-manager",
args.zk_server_ip)
_zookeeper_client.master_election(zk_path_pfx + "/device-manager",
os.getpid(), run_device_manager, args)
def main():
#removing config_db_uuid,useragent keyspaces
config = None
server_list = []
config = ConfigParser.SafeConfigParser({'admin_token': None})
config.read('/etc/contrail/contrail-api.conf')
server_list_str = config.get('DEFAULTS', 'cassandra_server_list')
server_list = server_list_str.split()
server_idx = 0
num_dbnodes = len(server_list)
connected = False
cass_server = None
while not connected:
try:
cass_server = server_list[server_idx]
sys_mgr = SystemManager(cass_server)
connected = True
except Exception as e:
server_idx = (server_idx + 1) % num_dbnodes
time.sleep(3)
uuid_keyspace_name = 'config_db_uuid'
agent_keyspace_name = 'useragent'
try:
print "deleting config_db_uuid keyspace"
sys_mgr.drop_keyspace(uuid_keyspace_name)
except pycassa.cassandra.ttypes.InvalidRequestException as e:
print "Warning! " + str(e)
try:
print "deleting useragent keyspace"
sys_mgr.drop_keyspace(agent_keyspace_name)
except pycassa.cassandra.ttypes.InvalidRequestException as e:
print "Warning! " + str(e)
#deleting znodes
_SUBNET_PATH = "/api-server/subnets"
_FQ_NAME_TO_UUID_PATH = "/fq-name-to-uuid"
_zk_client = None
while True:
try:
_zk_client = ZookeeperClient("api-" + '0', '127.0.0.1:2181')
break
except gevent.event.Timeout as e:
pass
print "deleting nodes at ", _SUBNET_PATH
_zk_client.delete_node(_SUBNET_PATH, True)
print "deleting nodes at ", _FQ_NAME_TO_UUID_PATH
_zk_client.delete_node(_FQ_NAME_TO_UUID_PATH, True)
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 = ''
_zookeeper_client = ZookeeperClient(client_pfx + "schema",
args.zk_server_ip,
zk_timeout=args.zk_timeout)
_zookeeper_client.master_election(zk_path_pfx + "/schema-transformer",
os.getpid(), run_schema_transformer,
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 main(args_str=None):
global _zookeeper_client
if not args_str:
args_str = ' '.join(sys.argv[1:])
args = parse_args(args_str)
args._args_list = 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
st_logger = SchemaTransformerLogger(args)
# Initialize AMQP handler then close it to be sure remain queue of a
# precedent run is cleaned
vnc_amqp = STAmqpHandle(st_logger, SchemaTransformer.REACTION_MAP, args)
vnc_amqp.establish()
vnc_amqp.close()
st_logger.debug("Removed remained AMQP queue")
# Waiting to be elected as master node
_zookeeper_client = ZookeeperClient(client_pfx + "schema",
args.zk_server_ip,
zk_timeout=args.zk_timeout)
st_logger.notice("Waiting to be elected as master...")
_zookeeper_client.master_election(zk_path_pfx + "/schema-transformer",
os.getpid(), run_schema_transformer,
st_logger, args)
def main(args_str=None):
global _amqp_client
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
dm_logger = DeviceManagerLogger(args, http_server_port=-1)
# Initialize AMQP handler then close it to be sure remain queue of a
# precedent run is cleaned
vnc_amqp = DMAmqpHandle(dm_logger, {}, args)
vnc_amqp.establish()
vnc_amqp.close()
dm_logger.debug("Removed remaining AMQP queue from previous run")
if 'host_ip' not in args:
args.host_ip = socket.gethostbyname(socket.getfqdn())
_amqp_client = initialize_amqp_client(dm_logger, args)
_zookeeper_client = ZookeeperClient(client_pfx + "device-manager",
args.zk_server_ip, args.host_ip)
try:
# Initialize the device job manager
DeviceJobManager(_amqp_client, _zookeeper_client, args, dm_logger)
# Allow kombu client to connect consumers
gevent.sleep(0.5)
except Exception as e:
dm_logger.error("Error while initializing the device job "
"manager %s" % str(e))
raise e
try:
# Initialize the device ztp manager
DeviceZtpManager(_amqp_client, args, dm_logger)
# Allow kombu client to connect consumers
gevent.sleep(0.5)
except Exception as e:
dm_logger.error("Error while initializing the device ztp "
"manager %s" % str(e))
raise e
gevent.signal(signal.SIGHUP, sighup_handler)
gevent.signal(signal.SIGTERM, sigterm_handler)
gevent.signal(signal.SIGINT, sigterm_handler)
dm_logger.notice("Waiting to be elected as master...")
_zookeeper_client.master_election(zk_path_pfx + "/device-manager",
os.getpid(), run_device_manager,
dm_logger, args)
def __init__(self, amqp_client, db_conn, args, dm_logger):
"""Initialize ZooKeeper, RabbitMQ, Sandesh, DB conn etc."""
DeviceJobManager._instance = self
self._amqp_client = amqp_client
# create zk client for devicejobmanager with call_back
self.client_reconnect_gl = None
self._zookeeper_client = ZookeeperClient("device-job-manager",
args.zk_server_ip,
args.host_ip)
self._zookeeper_client.set_lost_cb(self.client_reconnect)
self._db_conn = db_conn
self._args = args
self._job_mgr_statistics = {
'max_job_count': self._args.max_job_count,
'running_job_count': 0
}
# dict of exec_id:job_status (key/value pairs)
self.job_status = {}
# map of running job instances. Key is the pid and value is job
# instance info
self._job_mgr_running_instances = {}
job_args = {
'collectors': self._args.collectors,
'fabric_ansible_conf_file': self._args.fabric_ansible_conf_file,
'host_ip': self._args.host_ip,
'zk_server_ip': self._args.zk_server_ip,
'cluster_id': self._args.cluster_id
}
self._job_args = json.dumps(job_args)
# initialize the job logger
self._job_log_utils = JobLogUtils(
sandesh_instance_id="DeviceJobManager" + str(time.time()),
config_args=self._job_args,
sandesh_instance=dm_logger._sandesh)
self._logger = self._job_log_utils.config_logger
self._sandesh = self._logger._sandesh
self._amqp_client.add_exchange(self.JOB_STATUS_EXCHANGE, type='direct')
# add dummy consumer to initialize the exchange
self._amqp_client.add_consumer(
self.JOB_STATUS_CONSUMER + "dummy",
self.JOB_STATUS_EXCHANGE,
routing_key=self.JOB_STATUS_ROUTING_KEY + "dummy",
auto_delete=True)
self._amqp_client.add_exchange(self.JOB_REQUEST_EXCHANGE,
type='direct')
self._amqp_client.add_consumer(
self.JOB_REQUEST_CONSUMER,
self.JOB_REQUEST_EXCHANGE,
routing_key=self.JOB_REQUEST_ROUTING_KEY,
callback=self.handle_execute_job_request)
abort_q_name = '.'.join(
[self.JOB_ABORT_CONSUMER,
socket.getfqdn(self._args.host_ip)])
self._amqp_client.add_consumer(abort_q_name,
self.JOB_REQUEST_EXCHANGE,
routing_key=self.JOB_ABORT_ROUTING_KEY,
callback=self.handle_abort_job_request)
