def modify_cluster(self, cluster_data):
try:
cluster_id = cluster_data.get('id', None)
if not cluster_id:
raise Exception("No cluster id specified")
self.check_obj("cluster", {"id": cluster_id})
db_cluster = self.get_cluster({"id": cluster_id}, detail=True)
if not db_cluster:
msg = "%s is not valid" % cluster_id
raise ServerMgrException(msg)
db_cluster_params_str = db_cluster[0]['parameters']
db_cluster_params = {}
if db_cluster_params_str:
db_cluster_params = eval(db_cluster_params_str)
if 'uuid' not in db_cluster_params:
str_uuid = str(uuid.uuid4())
cluster_data["parameters"].update({"uuid": str_uuid})
# Store cluster_params dictionary as a text field
cluster_params = cluster_data.pop("parameters", {})
for k, v in cluster_params.iteritems():
if v == '""':
v = ''
db_cluster_params[k] = v
cluster_params = db_cluster_params
if cluster_params is not None:
cluster_data['parameters'] = str(cluster_params)
# Store email list as text field
email = cluster_data.pop("email", None)
if email is not None:
cluster_data['email'] = str(email)
self._modify_row(cluster_table, cluster_data, {'id': cluster_id},
{})
except Exception as e:
raise e
def modify_image(self, image_data):
try:
image_id = image_data.get('id', None)
if not image_id:
raise Exception("No image id specified")
#Reject if non mutable field changes
db_image = self.get_image({'id': image_data['id']}, detail=True)
if image_data['path'] != db_image[0]['path']:
raise ServerMgrException('Image path cannnot be modified')
if image_data['type'] != db_image[0]['type']:
raise ServerMgrException('Image type cannnot be modified')
# Store image_params dictionary as a text field
image_parameters = image_data.pop("parameters", None)
if image_parameters is not None:
image_data['parameters'] = str(image_parameters)
self._modify_row(image_table, image_data, {'id': image_id}, {})
except Exception as e:
raise e
def delete_cluster(self, match_dict=None, unmatch_dict=None):
try:
self.check_obj("cluster", match_dict, unmatch_dict)
cluster_id = match_dict.get("id", None)
servers = None
if cluster_id:
servers = self.get_server({'cluster_id': cluster_id},
detail=True)
if servers:
msg = ("Servers are present in this cluster, "
"remove cluster association, prior to cluster delete.")
raise ServerMgrException(msg)
self._delete_row(cluster_table, match_dict, unmatch_dict)
except Exception as e:
raise e
def storage_get_control_network_mask(self, provision_params,
server, cluster):
role_ips_dict = provision_params['roles']
cluster_params = cluster.get('parameters', {})
server_params = server.get('parameters', {})
#openstack_ip = cluster_params.get("internal_vip", None)
cluster_openstack_prov_params = (
cluster_params.get("provision", {})).get("openstack", {})
configured_external_keystone_ip = cluster_openstack_prov_params.get("keystone_ip", None)
openstack_ip = ''
self_ip = server.get("ip_address", "")
if configured_external_keystone_ip:
openstack_ip = configured_external_keystone_ip
elif self_ip in role_ips_dict['openstack']:
openstack_ip = self_ip
elif 'openstack' in role_ips_dict:
openstack_ip = role_ips_dict['openstack'][0]
else:
msg = "Openstack role not defined for cluster AND External Openstack not configured in cluster parameters.\n " \
"The cluster needs to point to at least one Openstack node.\n"
self._smgr_log.log(self._smgr_log.ERROR, msg)
raise ServerMgrException(msg, ERR_OPR_ERROR)
subnet_mask = server.get("subnet_mask", "")
if not subnet_mask:
subnet_mask = cluster_params.get("subnet_mask", "255.255.255.0")
subnet_address = ""
intf_control = {}
subnet_address = str(IPNetwork(
openstack_ip + "/" + subnet_mask).network)
if openstack_ip == configured_external_keystone_ip:
return '"' + str(IPNetwork(subnet_address).network) + '/' + str(IPNetwork(subnet_address).prefixlen) + '"'
self._smgr_log.log(self._smgr_log.DEBUG, "control-net : %s" % str( provision_params['control_net']))
if provision_params['control_net'] [openstack_ip]:
intf_control = eval(provision_params['control_net'] [openstack_ip])
self._smgr_log.log(self._smgr_log.DEBUG, "openstack-control-net : %s" % str(intf_control ))
for intf,values in intf_control.items():
if intf:
self._smgr_log.log(self._smgr_log.DEBUG, "ip_address : %s" % values['ip_address'])
return '"' + str(IPNetwork(values['ip_address']).network) + '/'+ str(IPNetwork(values['ip_address']).prefixlen) + '"'
else:
self._smgr_log.log(self._smgr_log.DEBUG, "server_ip : %s" % values['server_ip'])
return '"' + str(IPNetwork(provision_params['server_ip']).network) + '/'+ str(IPNetwork(provision_params['server_ip']).prefixlen) + '"'
return '"' + str(IPNetwork(subnet_address).network) + '/'+ str(IPNetwork(subnet_address).prefixlen) + '"'
def check_obj(self,
type,
match_dict=None,
unmatch_dict=None,
raise_exception=True):
if type == "server":
cb = self.get_server
db_obj = cb(match_dict, unmatch_dict, detail=False)
elif type == "cluster":
cb = self.get_cluster
db_obj = cb(match_dict, unmatch_dict, detail=False)
elif type == "image":
cb = self.get_image
db_obj = cb(match_dict, unmatch_dict, detail=False)
if not db_obj:
msg = "%s not found" % (type)
if raise_exception:
raise ServerMgrException(msg)
return False
return True
def log_and_raise_exception(self, msg, err_code=ERR_OPR_ERROR):
self._smgr_log.log(self._smgr_log.ERROR, msg)
raise ServerMgrException(msg, err_code)
def modify_server(self, server_data):
db_server = None
if 'id' in server_data.keys():
db_server = self.get_server({'id': server_data['id']}, detail=True)
elif 'mac_address' in server_data.keys():
db_server = self.get_server(
{'mac_address': server_data['mac_address']}, detail=True)
try:
cluster_id = server_data.get('cluster_id', None)
if cluster_id:
self.check_obj("cluster", {"id": cluster_id})
if 'mac_address' in server_data:
server_data['mac_address'] = str(
EUI(server_data['mac_address'])).replace("-", ":")
server_mac = server_data.get('mac_address', None)
if not server_mac:
server_id = server_data.get('id', None)
if not server_id:
raise Exception("No server MAC or id specified")
else:
server_mac = self.get_server_mac(server_id)
#Check if object exists
if 'id' in server_data.keys() and \
'server_mac' in server_data.keys():
self.check_obj('server', {'id': server_data['id']})
#Reject if primary key values change
if server_data['mac_address'] != db_server[0]['mac_address']:
raise ServerMgrException('MAC address cannnot be modified')
# Store roles list as a text field
roles = server_data.pop("roles", None)
if roles is not None:
server_data['roles'] = str(roles)
intf_control = server_data.pop("control_data_network", None)
if intf_control:
server_data['intf_control'] = str(intf_control)
intf_bond = server_data.pop("bond_interface", None)
if intf_bond:
server_data['intf_bond'] = str(intf_bond)
# store tags if any
server_tags = server_data.pop("tag", None)
if server_tags is not None:
tags_dict = self.get_server_tags(detail=True)
rev_tags_dict = dict((v, k) for k, v in tags_dict.iteritems())
for k, v in server_tags.iteritems():
server_data[rev_tags_dict[k]] = v
# Store server_params dictionary as a text field
server_params = server_data.pop("parameters", None)
#if server_params is not None:
# server_data['server_params'] = str(server_params)
#check for modify in db server_params
#Always Update DB server parmas
db_server_params = {}
db_server_params_str = db_server[0]['parameters']
if db_server_params_str:
db_server_params = eval(db_server_params_str)
if server_params:
for k, v in server_params.iteritems():
if v == '""':
v = ''
db_server_params[k] = v
server_data['parameters'] = str(db_server_params)
# Store email list as text field
email = server_data.pop("email", None)
if email is not None:
server_data['email'] = str(email)
self._modify_row(server_table, server_data,
{'mac_address': server_mac}, {})
except Exception as e:
raise e
def sandesh_init(self, sm_args, mon_config_set, inv_config_set):
# Inventory node module initialization part
try:
module = None
port = None
module_list = None
self._smgr_log.log(self._smgr_log.INFO, "Initializing sandesh")
collectors_ip_list = eval(sm_args.collectors)
if collectors_ip_list:
self._smgr_log.log(
self._smgr_log.INFO,
"Collector IPs from config: " + str(collectors_ip_list))
monitoring = True
inventory = True
if mon_config_set and inv_config_set:
try:
__import__('contrail_sm_monitoring.monitoring')
except ImportError:
mon_config_set = False
pass
try:
__import__('inventory_daemon.server_inventory')
except ImportError:
inv_config_set = False
pass
module = Module.INVENTORY_AGENT
port = int(sm_args.http_introspect_port)
module_list = [
'inventory_daemon.server_inventory',
'contrail_sm_monitoring.monitoring'
]
elif inv_config_set:
try:
__import__('inventory_daemon.server_inventory')
except ImportError:
inv_config_set = False
pass
module = Module.INVENTORY_AGENT
port = int(sm_args.http_introspect_port)
module_list = ['inventory_daemon.server_inventory']
elif mon_config_set:
try:
__import__('contrail_sm_monitoring.monitoring')
except ImportError:
mon_config_set = False
pass
module = Module.IPMI_STATS_MGR
port = int(sm_args.http_introspect_port)
module_list = ['contrail_sm_monitoring.monitoring']
if mon_config_set or inv_config_set:
module_name = ModuleNames[module]
node_type = Module2NodeType[module]
node_type_name = NodeTypeNames[node_type]
instance_id = INSTANCE_ID_DEFAULT
sandesh_global.init_generator(module_name,
socket.gethostname(),
node_type_name, instance_id,
collectors_ip_list,
module_name, port,
module_list)
sandesh_global.set_logging_params(
level=sm_args.sandesh_log_level)
else:
self._smgr_log.log(self._smgr_log.INFO,
"Sandesh wasn't initialized")
else:
pass
except Exception as e:
raise ServerMgrException("Error during Sandesh Init: " + str(e))
def build_openstack_hiera_file(
self, hiera_filename, provision_params,
server, cluster, cluster_servers):
cluster_params = cluster.get('parameters', {})
server_params = server.get('parameters', {})
# Get all values needed to fill the template.
self_ip = server.get("ip_address", "")
openstack_ips = [x["ip_address"] for x in cluster_servers if "openstack" in eval(x.get('roles', '[]'))]
cluster_openstack_prov_params = (cluster_params.get("provision", {})).get("openstack", {})
configured_external_keystone_ip = cluster_openstack_prov_params.get("keystone_ip", None)
if configured_external_keystone_ip:
openstack_ip = configured_external_keystone_ip
elif self_ip in openstack_ips:
openstack_ip = self_ip
elif len(openstack_ips):
openstack_ip = openstack_ips[0]
else:
msg = "Openstack role not defined for cluster AND External Openstack not configured in cluster parameters.\n " \
"The cluster needs to point to at least one Openstack node.\n"
self._smgr_log.log(self._smgr_log.ERROR, msg)
raise ServerMgrException(msg, ERR_OPR_ERROR)
subnet_mask = server.get("subnet_mask", "")
if not subnet_mask:
subnet_mask = cluster_params.get("subnet_mask", "255.255.255.0")
new_provision_params = cluster_params.get("provision", {})
openstack_params = new_provision_params.get("openstack", {})
if new_provision_params:
mysql_root_password = openstack_params.get("mysql", {}).get("root_password", "")
mysql_service_password = openstack_params.get("mysql", {}).get("service_password", "")
keystone_admin_password = openstack_params.get("keystone", {}).get("admin_password", "")
#Re-generate adming token if nothing was specified
#while creation.
#Ideally auto-generate woudl have created it.
#But old SM-code didn't
keystone_admin_token = openstack_params.get("keystone", {}).get("admin_token", self.random_string(12))
heat_encryption_key = openstack_params.get("heat",{}).get("encryption_key", "")
mysql_allowed_hosts = openstack_params.get("mysql_allowed_hosts", [])
if not mysql_allowed_hosts:
calc_cluster_params = cluster.get("calc_params", {})
mysql_allowed_hosts = calc_cluster_params.get("mysql_allowed_hosts", [])
# end if
else:
mysql_root_password = cluster_params.get("mysql_root_password", "")
mysql_service_password = cluster_params.get("mysql_service_password", "")
keystone_admin_password = cluster_params.get("keystone_password", "")
#Re-generate adming token if nothing was specified
#while creation.
#Ideally auto-generate woudl have created it.
#But old SM-code didn't
keystone_admin_token = cluster_params.get("keystone_admin_token", self.random_string(12))
heat_encryption_key = cluster_params.get("heat_encryption_key", "")
# Calculate list of hosts with mysql access granted.
mysql_allowed_hosts = []
internal_vip = cluster_params.get("internal_vip", None)
if internal_vip:
mysql_allowed_hosts.append(internal_vip)
external_vip = cluster_params.get("external_vip", None)
if external_vip:
mysql_allowed_hosts.append(external_vip)
contrail_internal_vip = cluster_params.get("contrail_internal_vip", None)
if contrail_internal_vip:
mysql_allowed_hosts.append(contrail_internal_vip)
contrail_external_vip = cluster_params.get("contrail_external_vip", None)
if contrail_external_vip:
mysql_allowed_hosts.append(contrail_external_vip)
os_ip_list = [self.get_control_ip(provision_params, x["ip_address"].encode('ascii')) \
for x in cluster_servers if 'openstack' in set(eval(x['roles']))]
config_ip_list = [self.get_control_ip(provision_params, x["ip_address"].encode('ascii')) \
for x in cluster_servers if 'config' in set(eval(x['roles']))]
role_ips_dict = provision_params['roles']
mysql_allowed_hosts = list(
set(mysql_allowed_hosts + os_ip_list + config_ip_list + role_ips_dict['config'] + role_ips_dict['openstack'] ))
# end else openstack_params
template_vals = {
'__openstack_ip__': openstack_ip,
'__subnet_mask__': subnet_mask,
'__mysql_root_password__': mysql_root_password,
'__mysql_service_password__': mysql_service_password,
'__keystone_admin_token__': keystone_admin_token,
'__keystone_admin_password__': keystone_admin_password,
'__mysql_allowed_hosts__': (', '.join("'" + item + "'" for item in mysql_allowed_hosts)),
'__openstack_password__': keystone_admin_password,
'__heat_encryption_key__': heat_encryption_key
}
data = openstack_hieradata.template.safe_substitute(template_vals)
outfile = open(hiera_filename, 'w')
outfile.write(data)
outfile.close()
def add_cluster_parameters(self, cluster_params):
cluster_params_mapping = {
"uuid" : ["uuid", "string"],
"internal_vip" : ["internal_vip", "string"],
"external_vip" : ["external_vip", "string"],
"contrail_internal_vip" : ["contrail_internal_vip", "string"],
"contrail_external_vip" : ["contrail_external_vip", "string"],
"internal_virtual_router_id" : ["internal_virtual_router_id", "integer"],
"external_virtual_router_id" : ["external_virtual_router_id", "integer"],
"contrail_internal_virtual_router_id" : ["contrail_internal_virtual_router_id", "integer"],
"contrail_external_virtual_router_id" : ["contrail_external_virtual_router_id", "integer"],
"analytics_data_ttl" : ["analytics_data_ttl", "integer"],
"analytics_config_audit_ttl" : ["analytics_config_audit_ttl", "integer"],
"analytics_statistics_ttl" : ["analytics_statistics_ttl", "integer"],
"analytics_flow_ttl" : ["analytics_flow_ttl", "integer"],
"snmp_scan_frequency" : ["snmp_scan_frequency", "integer"],
"snmp_fast_scan_frequency" : ["snmp_fast_scan_frequency", "integer"],
"topology_scan_frequency" : ["topology_scan_frequency", "integer"],
"analytics_syslog_port" : ["analytics_syslog_port", "integer"],
"database_dir" : ["database_dir", "string"],
"analytics_data_dir" : ["analytics_data_dir", "string"],
"ssd_data_dir" : ["ssd_data_dir", "string"],
"database_minimum_diskGB" : ["database_minimum_diskGB", "integer"],
"enable_lbass" : ["enable_lbass", "boolean"],
"redis_password" : ["redis_password", "string"],
"keystone_ip" : ["keystone_ip", "string"],
"keystone_password" : ["keystone_admin_password", "string"],
"keystone_username" : ["keystone_admin_user", "string"],
"keystone_tenant" : ["keystone_admin_tenant", "string"],
"keystone_service_tenant" : ["keystone_service_tenant", "string"],
"keystone_region_name" : ["keystone_region_name", "string"],
"multi_tenancy" : ["multi_tenancy", "boolean"],
"zookeeper_ip_list" : ["zookeeper_ip_list", "array"],
"haproxy" : ["haproxy_flag", "string"],
"hc_interval" : ["hc_interval", "integer"],
"nfs_server" : ["nfs_server", "string"],
"nfs_glance_path" : ["nfs_glance_path", "string"],
"database_token" : ["database_initial_token", "integer"],
"encapsulation_priority" : ["encap_priority", "string"],
"router_asn" : ["router_asn", "string"],
"external_bgp" : ["external_bgp", "string"],
"use_certificates" : ["use_certs", "boolean"],
"contrail_logoutput" : ["contrail_logoutput", "boolean"],
"enable_ceilometer": ["enable_ceilometer", "boolean"],
"xmpp_dns_auth_enable": ["xmpp_dns_auth_enable", "boolean"],
"xmpp_auth_enable": ["xmpp_auth_enable", "boolean"],
"contrail_amqp_ip_list": ["contrail_amqp_ip_list", "array"],
"contrail_amqp_port": ["contrail_amqp_port", "integer"],
"openstack_amqp_ip_list": ["openstack_amqp_ip_list", "array"],
"openstack_amqp_port": ["openstack_amqp_port", "integer"]
}
data = ''
try:
# Go thru all the keys above and if present, add to parameter list
for k,v in cluster_params_mapping.items():
if k in cluster_params:
# if value is text, add with quotes, else without the quotes.
if v[1].lower() == "string":
data += 'contrail::params::' + v[0] + ': "' + \
cluster_params.get(k, "") + '"\n'
else:
data += 'contrail::params::' + v[0] + ': ' + \
cluster_params.get(k, "") + '\n'
# end if-else
# end for
return data
except Exception as e:
msg = "%s, %s, %s:%s" % (repr(e), v, k, cluster_params.get(k))
self._smgr_log.log(self._smgr_log.ERROR, msg)
raise ServerMgrException(msg, ERR_OPR_ERROR)