def main(args_str=None):
if not args_str:
args_str = ' '.join(sys.argv[1:])
args = parse_args(args_str)
prog = EventManager(args.node_type)
collector_addr = []
if (args.node_type == 'storage-compute'):
try:
import discovery.client as client
except:
import discoveryclient.client as client
#storage node module initialization part
module = Module.STORAGE_STATS_MGR
module_name = ModuleNames[module]
node_type = Module2NodeType[module]
node_type_name = NodeTypeNames[node_type]
instance_id = INSTANCE_ID_DEFAULT
_disc = client.DiscoveryClient(args.disc_server_ip,
args.disc_server_port, module_name)
sandesh_global.init_generator(module_name, socket.gethostname(),
node_type_name, instance_id,
collector_addr, module_name,
HttpPortStorageStatsmgr,
['stats_daemon.sandesh.storage'], _disc)
sandesh_global.set_logging_params(enable_local_log=args.log_local,
category=args.log_category,
level=args.log_level,
file=args.log_file)
gevent.joinall([gevent.spawn(prog.runforever, sandesh_global)])
def main(args_str=None):
if not args_str:
args_str = ' '.join(sys.argv[1:])
args = parse_args(args_str)
# dump the read values
sys.stderr.write("node_type: " + args.node_type + "\n")
sys.stderr.write("Discovery ip: " + args.disc_server_ip + "\n")
sys.stderr.write("Discovery port: " + str(args.disc_server_port) + "\n")
# create event manager
prog = EventManager(args.node_type)
collector_addr = []
if (args.node_type == 'storage-compute'):
try:
import discovery.client as client
except:
import discoveryclient.client as client
#storage node module initialization part
module = Module.STORAGE_STATS_MGR
module_name = ModuleNames[module]
node_type = Module2NodeType[module]
node_type_name = NodeTypeNames[node_type]
instance_id = INSTANCE_ID_DEFAULT
_disc = client.DiscoveryClient(args.disc_server_ip,
args.disc_server_port, module_name)
sandesh_global.init_generator(module_name, socket.gethostname(),
node_type_name, instance_id,
collector_addr, module_name, 8103,
['stats_daemon.sandesh.storage'], _disc)
gevent.joinall([gevent.spawn(prog.runforever, sandesh_global)])
def __init__(self, vnc_lib, args=None):
self._args = args
#api server and cassandra init
self._vnc_lib = vnc_lib
self._cassandra_init()
#dictionary for nova
self._nova = {}
#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])
#sandesh init
collectors = None
if self._args.collector and self._args.collector_port:
collectors = [(self._args.collector,
int(self._args.collector_port))]
self._sandesh = Sandesh()
sandesh.ServiceInstanceList.handle_request = self.sandesh_si_handle_request
self._sandesh.init_generator(ModuleNames[Module.SVC_MONITOR],
socket.gethostname(), collectors,
'svc_monitor_context',
int(self._args.http_server_port),
['cfgm_common', 'sandesh'], self._disc)
self._sandesh.set_logging_params(enable_local_log=self._args.log_local,
category=self._args.log_category,
level=self._args.log_level,
file=self._args.log_file)
#create default analyzer template
self._create_default_template('analyzer-template', 'analyzer',
'analyzer')
self._create_default_template('nat-template', 'nat-service',
'firewall', 'in-network-nat')
#create cpu_info object to send periodic updates
sysinfo_req = False
cpu_info = vnc_cpu_info.CpuInfo(Module.SVC_MONITOR, sysinfo_req,
self._sandesh, 60)
self._cpu_info = cpu_info
# logging
self._err_file = '/var/log/contrail/svc-monitor.err'
self._tmp_file = '/var/log/contrail/svc-monitor.tmp'
self._svc_err_logger = logging.getLogger('SvcErrLogger')
self._svc_err_logger.setLevel(logging.ERROR)
handler = logging.handlers.RotatingFileHandler(
self._err_file, maxBytes=_ERROR_LOG_FILE_SIZE, backupCount=2)
self._svc_err_logger.addHandler(handler)
def get_discovery_client(self, Config):
try:
import discovery.client as client
except:
import discoveryclient.client as client
if self.discovery_server == socket.gethostname():
self.get_discovery_server(Config)
self.get_discovery_port(Config)
_disc = client.DiscoveryClient(self.discovery_server,
self.discovery_port, self.module_id)
return _disc
def main(args_str=None):
if not args_str:
args_str = ' '.join(sys.argv[1:])
args = parse_args(args_str)
prog = EventManager(args.node_type)
collector_addr = []
if (args.node_type == 'storage-compute'
or args.node_type == 'storage-master'):
try:
import discovery.client as client
except:
import discoveryclient.client as client
#storage node module initialization part
module = Module.STORAGE_STATS_MGR
module_name = ModuleNames[module]
node_type = Module2NodeType[module]
node_type_name = NodeTypeNames[node_type]
instance_id = INSTANCE_ID_DEFAULT
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})
_disc = client.DiscoveryClient(args.disc_server_ip,
args.disc_server_port, module_name,
**dss_kwargs)
#if args.sandesh_send_rate_limit is not None:
# SandeshSystem.set_sandesh_send_rate_limit( \
# args.sandesh_send_rate_limit)
sandesh_global.init_generator(module_name, socket.gethostname(),
node_type_name, instance_id,
collector_addr, module_name,
HttpPortStorageStatsmgr,
['stats_daemon.sandesh.storage'], _disc)
sandesh_global.set_logging_params(enable_local_log=args.log_local,
category=args.log_category,
level=args.log_level,
file=args.log_file,
enable_syslog=False,
syslog_facility='LOG_LOCAL0')
gevent.joinall([gevent.spawn(prog.runforever)])
def main(argv=sys.argv):
# Parse Arguments
import argparse
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("--rules",
default='',
help='Rules file to use for processing events')
parser.add_argument("--nodetype",
default='contrail-analytics',
help='Type of node which nodemgr is managing')
parser.add_argument("--discovery_server",
default=socket.gethostname(),
help='IP address of Discovery Server')
parser.add_argument(
"--collectors",
default='',
help='Collector addresses in format ip1:port1 ip2:port2')
parser.add_argument("--discovery_port",
type=int,
default=5998,
help='Port of Discovery Server')
try:
_args = parser.parse_args()
except:
usage()
rule_file = _args.rules
node_type = _args.nodetype
discovery_server = _args.discovery_server
sys.stderr.write("Discovery server: " + discovery_server + "\n")
discovery_port = _args.discovery_port
sys.stderr.write("Discovery port: " + str(discovery_port) + "\n")
if _args.collectors is "":
collector_addr = []
else:
collector_addr = _args.collectors.split()
sys.stderr.write("Collector address: " + str(collector_addr) + "\n")
#done parsing arguments
if not 'SUPERVISOR_SERVER_URL' in os.environ:
sys.stderr.write('Node manager must be run as a supervisor event '
'listener\n')
sys.stderr.flush()
return
if rule_file == "":
if (node_type == 'contrail-analytics'):
rule_file = "/etc/contrail/supervisord_analytics_files/contrail-analytics.rules"
if (node_type == 'contrail-config'):
rule_file = "/etc/contrail/supervisord_config_files/contrail-config.rules"
if (node_type == 'contrail-control'):
rule_file = "/etc/contrail/supervisord_control_files/contrail-control.rules"
if (node_type == 'contrail-vrouter'):
rule_file = "/etc/contrail/supervisord_vrouter_files/contrail-vrouter.rules"
if (node_type == 'contrail-database'):
rule_file = "/etc/contrail/supervisord_database_files/supervisord_contrail_database.rules"
if rule_file is "":
sys.stderr.write('Node manager must be invoked with a rules file\n')
sys.stderr.flush()
return
json_file = open(rule_file)
json_data = json.load(json_file)
prog = EventManager(json_data, node_type)
#initialize sandesh
if (node_type is 'contrail-analytics'):
# since this is local node, wait for sometime to let collector come up
import time
try:
import discovery.client as client
except:
import discoveryclient.client as client
module = Module.ANALYTICS_NODE_MGR
module_name = ModuleNames[module]
node_type = Module2NodeType[module]
node_type_name = NodeTypeNames[node_type]
instance_id = INSTANCE_ID_DEFAULT
#Read collector info from the conf file
#If conf file is indented ConfigParser cannot read, so stripping the contents
import ConfigParser
from StringIO import StringIO
data = StringIO('\n'.join(
line.strip()
for line in open('/etc/contrail/contrail-collector.conf')))
Config = ConfigParser.SafeConfigParser()
Config.readfp(data)
if discovery_server == socket.gethostname():
discovery_server = Config.get("DISCOVERY", "server")
#Hack becos of Configparser and the conf file format itself
try:
discovery_server = discovery_server[:discovery_server.
index('#')].strip()
except:
discovery_server = discovery_server.strip()
_disc = client.DiscoveryClient(discovery_server, discovery_port,
module_name)
# ubuntu packaging is different, figure out where the generated files
# are installed
try:
from opserver.sandesh.analytics.ttypes import *
sandesh_pkg_dir = 'opserver.sandesh'
except:
from analytics.ttypes import *
sandesh_pkg_dir = 'analytics'
sandesh_global.init_generator(module_name, socket.gethostname(),
node_type_name, instance_id,
collector_addr, module_name, 8104,
[sandesh_pkg_dir], _disc)
sandesh_global.set_logging_params(enable_local_log=True)
if (node_type == 'contrail-config'):
try:
import discovery.client as client
except:
import discoveryclient.client as client
# since this may be a local node, wait for sometime to let collector come up
import time
# read discovery client info from config file
import ConfigParser
module = Module.CONFIG_NODE_MGR
module_name = ModuleNames[module]
node_type = Module2NodeType[module]
node_type_name = NodeTypeNames[node_type]
instance_id = INSTANCE_ID_DEFAULT
Config = ConfigParser.ConfigParser()
Config.read("/etc/contrail/contrail-api.conf")
discovery_server = Config.get("DEFAULTS", "disc_server_ip")
discovery_port = Config.get("DEFAULTS", "disc_server_port")
sys.stderr.write("Updated discovery server: " + discovery_server +
"\n")
sys.stderr.write("Updated discovery port: " + str(discovery_port) +
"\n")
_disc = client.DiscoveryClient(discovery_server, discovery_port,
module_name)
sandesh_global.init_generator(module_name, socket.gethostname(),
node_type_name, instance_id,
collector_addr, module_name, 8100,
['cfgm_common.uve'], _disc)
#sandesh_global.set_logging_params(enable_local_log=True)
if (node_type == 'contrail-control'):
try:
import discovery.client as client
except:
import discoveryclient.client as client
# since this may be a local node, wait for sometime to let collector come up
import time
import ConfigParser
module = Module.CONTROL_NODE_MGR
module_name = ModuleNames[module]
node_type = Module2NodeType[module]
node_type_name = NodeTypeNames[node_type]
instance_id = INSTANCE_ID_DEFAULT
from StringIO import StringIO
data = StringIO('\n'.join(
line.strip()
for line in open('/etc/contrail/contrail-control.conf')))
Config = ConfigParser.SafeConfigParser()
Config.readfp(data)
if discovery_server == socket.gethostname():
discovery_server = Config.get("DISCOVERY", "server")
#Hack becos of Configparser and the conf file format itself
try:
discovery_server = discovery_server[:discovery_server.
index('#')].strip()
except:
discovery_server = discovery_server.strip()
_disc = client.DiscoveryClient(discovery_server, discovery_port,
module_name)
sandesh_global.init_generator(module_name, socket.gethostname(),
node_type_name, instance_id,
collector_addr, module_name, 8101,
['control_node.control_node'], _disc)
#sandesh_global.set_logging_params(enable_local_log=True)
if (node_type == 'contrail-vrouter'):
try:
import discovery.client as client
except:
import discoveryclient.client as client
# since this may be a local node, wait for sometime to let collector come up
import time
module = Module.COMPUTE_NODE_MGR
module_name = ModuleNames[module]
node_type = Module2NodeType[module]
node_type_name = NodeTypeNames[node_type]
instance_id = INSTANCE_ID_DEFAULT
#Read the discovery server info from the conf file
import ConfigParser
from StringIO import StringIO
data = StringIO('\n'.join(
line.strip()
for line in open('/etc/contrail/contrail-vrouter-agent.conf')))
Config = ConfigParser.SafeConfigParser()
Config.readfp(data)
if discovery_server == socket.gethostname():
discovery_server = Config.get("DISCOVERY", "server")
#Hack becos of Configparser and the conf file format itself
discovery_server = discovery_server.strip()
_disc = client.DiscoveryClient(discovery_server, discovery_port,
module_name)
sandesh_global.init_generator(module_name, socket.gethostname(),
node_type_name, instance_id,
collector_addr, module_name, 8102,
['vrouter.vrouter'], _disc)
#sandesh_global.set_logging_params(enable_local_log=True)
if (node_type == 'contrail-database'):
try:
import discovery.client as client
except:
import discoveryclient.client as client
module = Module.DATABASE_NODE_MGR
module_name = ModuleNames[module]
node_type = Module2NodeType[module]
node_type_name = NodeTypeNames[node_type]
instance_id = INSTANCE_ID_DEFAULT
#Read the discovery server info from the conf file
import ConfigParser
from StringIO import StringIO
data = StringIO('\n'.join(
line.strip()
for line in open('/etc/contrail/contrail-database-nodemgr.conf')))
Config = ConfigParser.SafeConfigParser()
Config.readfp(data)
if discovery_server == socket.gethostname():
discovery_server = Config.get("DISCOVERY", "server")
#Hack becos of Configparser and the conf file format itself
discovery_server = discovery_server.strip()
_disc = client.DiscoveryClient(discovery_server, discovery_port,
module_name)
sandesh_global.init_generator(module_name, socket.gethostname(),
node_type_name, instance_id, [],
module_name, 8103, ['database.sandesh'],
_disc)
#sandesh_global.set_logging_params(enable_local_log=True)
gevent.joinall([gevent.spawn(prog.runforever, sandesh_global)])
