diff --git a/src/server_mgr_main.py b/src/server_mgr_main.py index d5144ab1..24df517d 100755 --- a/src/server_mgr_main.py +++ b/src/server_mgr_main.py @@ -3837,27 +3837,6 @@ def find_package_sku(self, image_id, image_type): else: msg = ("find_package_sku: unable to find version from package") raise ServerMgrException(msg, ERR_OPR_ERROR) - - def package_sku(self, package_id): - ## as of now, default assumption is juno - sku = 'juno' - try: - package_id, package = self.get_package_image(package_id) - sku = eval(package['parameters']).get('sku', "juno") - except ServerMgrException as e: - self._smgr_log.log(self._smgr_log.DEBUG, "exception for sku %s" %e) - pass - return sku - - def package_version(self, package_id): - version = '' - try: - package_id, package = self.get_package_image(package_id) - version = eval(package['parameters']).get('version', '') - except ServerMgrException as e: - self._smgr_log.log(self._smgr_log.DEBUG, "exception for version %s" %e) - pass - return version def storage_get_control_network_mask( self, server, cluster, role_servers, cluster_servers): @@ -4274,313 +4253,15 @@ def provision_server(self): self.build_calculated_provision_params( server, cluster, role_servers, cluster_servers, package) else: - # This code in else can be removed when we stop supporting old format parameters for cluster and server. - provision_params['sequence_provisioning'] = sequence_provisioning - provision_params['sequence_provisioning_available'] = self.is_sequence_provisioning_available(package_image_id) - puppet_manifest_version = server_pkg['puppet_manifest_version'] - provision_params['package_image_id'] = package_image_id - provision_params['package_version'] = self.package_version(package_image_id) - provision_params['package_sku'] = self.package_sku(package_image_id) - provision_params['package_type'] = package_type - provision_params['puppet_manifest_version'] = puppet_manifest_version - provision_params['server_mgr_ip'] = self._args.listen_ip_addr - provision_params['roles'] = role_ips - provision_params['role_ids'] = role_ids - provision_params['server_id'] = server['id'] - if server['domain']: - provision_params['domain'] = server['domain'] - else: - provision_params['domain'] = cluster_params['domain'] - if not provision_params['domain']: - msg = "No Domain specified either for server " + provision_params['server_id'] + " or cluster " + server["cluster_id"] - self.log_and_raise_exception(msg) - provision_params['rmq_master'] = role_ids['config'][0] - provision_params['uuid'] = cluster_params['uuid'] - provision_params['smgr_ip'] = self._args.listen_ip_addr - server['parameters']['smgr_ip'] = self._args.listen_ip_addr - if role_ids['config'][0] == server['id']: - provision_params['is_rmq_master'] = "yes" - else: - provision_params['is_rmq_master'] = "no" - provision_params['intf_control'] = "" - provision_params['intf_bond'] = "" - provision_params['intf_data'] = "" - if 'intf_control' in server: - provision_params['intf_control'] = server['intf_control'] - if 'intf_data' in server: - provision_params['intf_data'] = server['intf_data'] - if 'intf_bond' in server: - provision_params['intf_bond'] = server['intf_bond'] - provision_params['control_net'] = self.get_control_net(cluster_servers) - provision_params['interface_list'] = self.get_interfaces(server) - provision_params['server_ip'] = server['ip_address'] - if 'contrail' in server: - provision_params['contrail_params'] = server['contrail'] - if 'kernel_upgrade' in server_params and server_params['kernel_upgrade']: - provision_params['kernel_upgrade'] = server_params['kernel_upgrade'] - elif 'kernel_upgrade' in cluster_params and cluster_params['kernel_upgrade']: - provision_params['kernel_upgrade'] = cluster_params['kernel_upgrade'] - else: - provision_params['kernel_upgrade'] = DEFAULT_KERNEL_UPGRADE - - if 'kernel_version' in server_params and server_params['kernel_version']: - provision_params['kernel_version'] = server_params['kernel_version'] - elif 'kernel_version' in cluster_params and cluster_params['kernel_version']: - provision_params['kernel_version'] = cluster_params['kernel_version'] - else: - provision_params['kernel_version'] = DEFAULT_KERNEL_VERSION - - #DPDK Hugepages - if 'huge_pages' in server_params and server_params['huge_pages']: - provision_params['huge_pages'] = server_params['huge_pages'] - elif 'huge_pages' in cluster_params and cluster_params['huge_pages']: - provision_params['huge_pages'] = cluster_params['huge_pages'] - else: - provision_params['huge_pages'] = "" + self._smgr_trans_log.log(bottle.request, + self._smgr_trans_log.SMGR_PROVISION, + False) + resp_msg = self.form_operartion_data("Cluster "+str(cluster_id) + " uses old params format. " + "This is no longer supported. " + "Please switch to new params format for cluster config.", + ERR_GENERAL_ERROR, provision_status) + abort(404, resp_msg) - #DPDK Coremask - if 'core_mask' in server_params and server_params['core_mask']: - provision_params['core_mask'] = server_params['core_mask'] - elif 'core_mask' in cluster_params and cluster_params['core_mask']: - provision_params['core_mask'] = cluster_params['core_mask'] - else: - provision_params['core_mask'] = "" - - if 'esx_server' in server_params.keys(): - provision_params['esx_uplink_nic'] = server_params['esx_uplink_nic'] - provision_params['esx_fab_vswitch'] = server_params['esx_fab_vswitch'] - provision_params['esx_vm_vswitch'] = server_params['esx_vm_vswitch'] - provision_params['esx_fab_port_group'] = server_params['esx_fab_port_group'] - provision_params['esx_vm_port_group'] = server_params['esx_vm_port_group'] - provision_params['vm_deb'] = server_params['vm_deb'] if server_params.has_key('vm_deb') else "" - provision_params['esx_vmdk'] = server_params['esx_vmdk'] - esx_servers = self._serverDb.get_server( - {'id' : server_params['esx_server']}, - detail=True) - esx_server = esx_servers[0] - provision_params['esx_ip'] = esx_server['ip_address'] - provision_params['esx_username'] = "root" - provision_params['esx_password'] = esx_server['password'] - provision_params['esx_server'] = esx_server - provision_params['server_mac'] = server['mac_address'] - provision_params['password'] = server['password'] - if 'datastore' in server_params.keys(): - provision_params['datastore'] = server_params['datastore'] - else: - provision_params['datastore'] = "/vmfs/volumes/datastore1" - else: - provision_params['esx_uplink_nic'] = "" - provision_params['esx_fab_vswitch'] = "" - provision_params['esx_vm_vswitch'] = "" - provision_params['esx_fab_port_group'] = "" - provision_params['esx_vm_port_group'] = "" - provision_params['esx_vmdk'] = "" - provision_params['esx_ip'] = "" - provision_params['esx_username'] = "" - provision_params['esx_password'] = "" - - if 'external_bgp' in cluster_params.keys(): - provision_params['external_bgp'] = cluster_params['external_bgp'] - else: - provision_params['external_bgp'] = "" - - # Storage role params - - if 'subnet_mask' in server and server['subnet_mask']: - subnet_mask = server['subnet_mask'] - elif 'subnet_mask' in cluster_params and cluster_params['subnet_mask']: - subnet_mask = cluster_params['subnet_mask'] - - if 'toragent' in server['roles']: - if not 'tsn' in server['roles']: - msg = "TSN must be configured on node with ToR Agent" - raise ServerMgrException(msg) - - if 'toragent' in server['roles']: - provision_params['top_of_rack'] = server_tor_config - self._smgr_log.log(self._smgr_log.DEBUG, "TOR-AGENT is there") - else: - self._smgr_log.log(self._smgr_log.DEBUG, "TOR-AGENT is not there") - provision_params['top_of_rack'] = "" - provision_params['tor_ha_config'] = {} - for role_server in role_servers['toragent']: - server_params_compute = eval(role_server['top_of_rack']) - if len(server_params_compute) > 0: - #self._smgr_log.log(self._smgr_log.DEBUG, "TOR1 of %s => %s" % (role_server['id'],server_params_compute)) - node_id = role_server['id'] - switches = server_params_compute['switches'] - provision_params['tor_ha_config'][node_id]= {} - provision_params['tor_ha_config'][node_id]['switches'] = switches - host_control_ip = self._smgr_puppet.get_control_ip(provision_params, role_server.get('ip_address', "")) - provision_params['tor_ha_config'][node_id]['tsn_ip'] = str(host_control_ip) - #self._smgr_log.log(self._smgr_log.DEBUG, "TOR3 %s => %s" % (server['id'],server_params_compute['switch_name'])) - #for i in range(len(switches)): - #switch_detail = {} - #switch_detail['tor_name'] = switches[i]['switch_name'] - #switch_detail['ovs_port'] = switches[i]['ovs_port'] - #switch_detail['protocol'] = switches[i]['ovs_protocol'] - #host_control_ip = self._smgr_puppet.get_control_ip(provision_params, role_server.get('ip_address', "")) - #switch_detail['tsn_ip'] = host_control_ip - #provision_params['tor_ha_config'][node_id].append(switch_detail) - - #self._smgr_log.log(self._smgr_log.DEBUG, "tor config of %s => %s" % (server['id'], server_tor_config)) - self._smgr_log.log(self._smgr_log.DEBUG, "TOR2 %s => %s" % (server['id'], provision_params['tor_ha_config'])) - if len(role_servers['storage-compute']): - msg = "Storage is enabled" - storage_status = '1' - else: - msg = "Storage is disabled" - storage_status = '0' - self._smgr_log.log(self._smgr_log.DEBUG, msg) - - if (('storage-compute' in server['roles']) - or ('storage-master' in server['roles'])): - if (('storage_repo_id' not in server_params.keys()) or - (server_params['storage_repo_id'] == "")): - msg = ("server parameters needs to have storage_repo_id" - " for storage roles") - raise ServerMgrException(msg, ERR_OPR_ERROR) - - # Calculate the total number of disks in the cluster - total_osd = int(0) - num_storage_hosts = int(0) - live_migration = "disable" - live_migration_host = "" - live_migration_ip = "" - live_migration_storage_scope = "local" - for role_server in role_servers['storage-compute']: - server_params_compute = eval(role_server['parameters']) - if 'disks' in server_params_compute and len(server_params_compute['disks']) > 0: - total_osd += len(server_params_compute['disks']) - num_storage_hosts += 1 - else: - pass - - if 'live_migration' in cluster_params.keys() and cluster_params['live_migration'] == "enable": - if 'live_migration_nfs_vm_host' in cluster_params.keys() and cluster_params['live_migration_nfs_vm_host'] and len(cluster_params['live_migration_nfs_vm_host']) > 0 : - live_migration = "enable" - live_migration_host = cluster_params['live_migration_nfs_vm_host'] - else: - live_migration = "disable" - live_migration_host = "" - - if 'live_migration_storage_scope' in cluster_params.keys() and cluster_params['live_migration_storage_scope']: - live_migration_storage_scope = cluster_params['live_migration_storage_scope'] - else: - pass - - if live_migration_storage_scope == "local" or live_migration_storage_scope == "global": - pass - else: - msg = "Invalid Live Migration Storage Scope (local/global are valid)" - raise ServerMgrException(msg) - - - provision_params['live_migration_storage_scope'] = live_migration_storage_scope - provision_params['contrail-storage-enabled'] = storage_status - provision_params['subnet-mask'] = subnet_mask - provision_params['host_roles'] = [ x.encode('ascii') for x in eval(server['roles']) ] - provision_params['storage_num_osd'] = total_osd - provision_params['storage_fsid'] = cluster_params['storage_fsid'] - provision_params['storage_virsh_uuid'] = cluster_params['storage_virsh_uuid'] - provision_params['num_storage_hosts'] = num_storage_hosts - provision_params['live_migration_host'] = live_migration_host - provision_params['live_migration_ip'] = "" - if len(role_servers['storage-compute']): - if len(role_servers['storage-master']) == 0: - msg = "Storage nodes can only be provisioned when there is also a Storage-Manager node" - raise ServerMgrException(msg) - if 'storage_mon_secret' in cluster_params.keys() and cluster_params['storage_mon_secret']: - if len(cluster_params['storage_mon_secret']) == 40: - provision_params['storage_mon_secret'] = cluster_params['storage_mon_secret'] - else: - msg = "Storage Monitor Secret Key is the wrong length" - raise ServerMgrException(msg) - else: - provision_params['storage_mon_secret'] = "" - if 'osd_bootstrap_key' in cluster_params.keys() and cluster_params['osd_bootstrap_key']: - if len(cluster_params['osd_bootstrap_key']) == 40: - provision_params['osd_bootstrap_key'] = cluster_params['osd_bootstrap_key'] - else: - msg = "OSD Bootstrap Key is the wrong length" - raise ServerMgrException(msg) - else: - provision_params['osd_bootstrap_key'] = "" - if 'admin_key' in cluster_params.keys() and cluster_params['admin_key']: - if len(cluster_params['admin_key']) == 40: - provision_params['admin_key'] = cluster_params['admin_key'] - else: - msg = "Admin Key is the wrong length" - raise ServerMgrException(msg) - else: - provision_params['admin_key'] = "" - if 'disks' in server_params and server_params['disks'] and total_osd > 0: - provision_params['storage_server_disks'] = [] - provision_params['storage_server_disks'].extend(server_params['disks']) - - storage_mon_host_ip_set = set() - storage_mon_hostname_set = set() - storage_chassis_config_set = set() - for x in role_servers['storage-compute']: - storage_mon_host_ip_set.add(self._smgr_puppet.get_control_ip(provision_params, x["ip_address"]).strip('"')) - storage_mon_hostname_set.add(x['id']) - if x['id'] == live_migration_host: - live_migration_ip = self._smgr_puppet.get_control_ip(provision_params, x["ip_address"]).strip('"') - self._smgr_log.log(self._smgr_log.DEBUG, "live-M ip = %s" % live_migration_ip) - provision_params['live_migration_ip'] = live_migration_ip - server_params_compute = eval(x['parameters']) - if 'storage_chassis_id' in server_params_compute.keys() and server_params_compute['storage_chassis_id']: - storage_chassis_id = [x['id'], ':', server_params_compute['storage_chassis_id']] - storage_host_chassis = ''.join(storage_chassis_id) - storage_chassis_config_set.add(storage_host_chassis) - for x in role_servers['storage-master']: - storage_mon_host_ip_set.add(self._smgr_puppet.get_control_ip(provision_params, x["ip_address"]).strip('"')) - storage_mon_hostname_set.add(x['id']) - - provision_params['storage_monitor_hosts'] = list(storage_mon_host_ip_set) - provision_params['storage_hostnames'] = list(storage_mon_hostname_set) - provision_params['storage_chassis_config'] = list(storage_chassis_config_set) - - # Multiple Repo support - if 'storage_repo_id' in server_params.keys() and server_params['storage_repo_id']: - images = self.get_image() - image_ids = dict() - for image in images['image']: - match_dict = dict() - match_dict["id"] = image['id'] - cur_image = self._serverDb.get_image(match_dict, None, detail=True) - if cur_image is not None: - image_ids[image['id']] = cur_image[0]['type'] - else: - msg = "No images found" - self.log_and_raise_exception(msg) - if server_params['storage_repo_id'] in image_ids: - if image_ids[server_params['storage_repo_id']] == 'contrail-storage-ubuntu-package': - provision_params['storage_repo_id'] = server_params['storage_repo_id'] - else: - msg = "Storage repo id specified doesn't match a contrail storage package" - raise ServerMgrException(msg) - else: - msg = "Storage repo id specified doesn't match any of the image ids" - raise ServerMgrException(msg) - else: - provision_params['storage_repo_id'] = "" - - # Storage manager restrictions - if len(role_servers['storage-master']): - if len(role_servers['storage-master']) > 1: - # if HA is configured, there may be more than 1 storage-master - if cluster_params.get("internal_vip", "") == "" : - msg = "There can only be only one node with the role 'storage-master'" - raise ServerMgrException(msg) - else: - pass - elif len(role_servers['storage-compute']) == 0: - msg = "Storage manager node needs Storage nodes to also be provisioned" - raise ServerMgrException(msg) - else: - pass - #end if (role_servers['storage-master']) # end else of "provision" in cluster_params provision_server_entry = {'provision_params' : copy.deepcopy(provision_params), 'server' : copy.deepcopy(server), @@ -5097,14 +4778,6 @@ def generate_passwords(self, params): "encryption_key", self.random_string(16)) - else: - #old params - self._smgr_log.log(self._smgr_log.INFO, "generating passwords for old params") - params["mysql_root_password"] = params.get("mysql_root_password", self.random_string(12)) - params["mysql_service_password"] = params.get("mysql_service_password", self.random_string(12)) - params["keystone_password"] = params.get("keystone_password", self.random_string(12)) - params["keystone_admin_token"] = params.get("keystone_admin_token", self.random_string(12)) - params["heat_encryption_key"] = params.get("heat_encryption_key", self.random_string(16)) # End class VncServerManager() diff --git a/src/server_mgr_puppet.py b/src/server_mgr_puppet.py index 51b75672..3dddac21 100644 --- a/src/server_mgr_puppet.py +++ b/src/server_mgr_puppet.py @@ -40,33 +40,6 @@ def __init__(self, smgr_base_dir, puppet_dir): os.makedirs(os.path.dirname(puppet_dir)) # end __init__ - #API to return control interfaces IP address - # else return MGMT IP address - def get_control_ip(self, provision_params, mgmt_ip): - intf_control = {} - """ - if 'contrail_params' in provision_params: - contrail_dict = eval(provision_params['contrail_params']) - control_data_intf = contrail_dict['control_data_interface'] - if provision_params['interface_list'] and \ - provision_params['interface_list'] [control_data_intf]: - control_data_ip = provision_params['interface_list'] \ - [control_data_intf] ['ip'] - if control_data_ip: - return '"' + str(IPNetwork(control_data_ip).ip) + '"' - else: - return '"' + provision_params['server_ip'] + '"' - """ - if provision_params['control_net'] [mgmt_ip]: - intf_control = eval(provision_params['control_net'] [mgmt_ip]) - for intf,values in intf_control.items(): - if intf: - return str(IPNetwork(values['ip_address']).ip) - else: - return provision_params['server_ip'] - return mgmt_ip - # end get_control_ip - def storage_get_control_network_mask(self, provision_params, server, cluster): role_ips_dict = provision_params['roles'] @@ -244,79 +217,6 @@ def add_node_entry_new( os.chmod(site_file, 0644) # end def add_node_entry_new - 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_lbaas" : ["enable_lbaas", "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) - # end add cluster_parameters - def initiate_esx_contrail_vm(self, server, esx_server): self._smgr_log.log(self._smgr_log.DEBUG, "esx_server") #call scripts to provision esx @@ -348,19 +248,6 @@ def initiate_esx_contrail_vm(self, server, esx_server): self._smgr_log.log(self._smgr_log.DEBUG, "ContrilVM:" %(out)) # end initiate_esx_contrail_vm - def add_contrail_upgrade( - self, server, provision_parameters): - data = '' - - #Set the flag only when targets image_id is not equal to what it is going - #to be provisoned with - if server.get('provisioned_id', "") != "" and \ - server.get('provisioned_id',"") != provision_parameters.get('package_image_id', ""): - data += 'contrail::params::contrail_upgrade: %s\n' %( - True) - - return data - def generate_tor_certs(self, switch_info, server_id, domain): tor_name = switch_info['switch_name'] tor_vendor_name = switch_info['vendor_name'] @@ -384,206 +271,6 @@ def generate_tor_certs(self, switch_info, server_id, domain): subprocess.check_call(cert_cmd, shell=True) - def build_contrail_hiera_file( - self, hiera_filename, provision_params, - server, cluster, cluster_servers): - cluster_params = cluster.get('parameters', {}) - # By default, sequence provisioning is On. - sequence_provisioning = provision_params['sequence_provisioning'] - sequence_provisioning_available = provision_params['sequence_provisioning_available'] - server_params = server.get('parameters', {}) - data = '' - package_ids = [provision_params.get('package_image_id', "").encode('ascii')] - package_types = [provision_params.get('package_type', "").encode('ascii')] - if 'storage-compute' in provision_params['host_roles'] or 'storage-master' in provision_params['host_roles']: - package_ids.append(provision_params.get('storage_repo_id', "").encode('ascii')) - package_types.append("contrail-ubuntu-storage-repo".encode('ascii')) - data += 'contrail::params::contrail_repo_name: %s\n' %(str(package_ids)) - data += 'contrail::params::contrail_repo_type: %s\n' %(str(package_types)) - - data += 'contrail::params::host_ip: "%s"\n' %( - self.get_control_ip(provision_params, server.get('ip_address', ""))) - - data += 'contrail::params::contrail_version: "%s"\n' %(provision_params['package_version']) - data += 'contrail::package_sku: "%s"\n' %(provision_params['package_sku']) - - #Upgrade Kernel - if 'kernel_upgrade' in provision_params and \ - provision_params['kernel_upgrade'] != DEFAULT_KERNEL_UPGRADE : - data += 'contrail::params::kernel_upgrade: "%s"\n' %( - provision_params.get('kernel_upgrade', DEFAULT_KERNEL_UPGRADE)) - if 'kernel_version' in provision_params and \ - provision_params['kernel_version'] != DEFAULT_KERNEL_VERSION : - data += 'contrail::params::kernel_version: "%s"\n' %( - provision_params.get('kernel_version', DEFAULT_KERNEL_VERSION)) - if 'external_bgp' in provision_params and \ - provision_params['external_bgp'] : - data += 'contrail::params::external_bgp: "%s"\n' %( - provision_params.get('external_bgp', "")) - if "uuid" in cluster_params: - data += 'contrail::params::uuid: "%s"\n' %( - cluster_params.get('uuid', "")) - - if 'huge_pages' in provision_params and \ - provision_params['huge_pages'] != DEFAULT_HUGE_PAGES : - data += 'contrail::params::huge_pages: "%s"\n' %( - provision_params.get('huge_pages', DEFAULT_HUGE_PAGES)) - - if 'core_mask' in provision_params and \ - provision_params['core_mask'] != DEFAULT_CORE_MASK : - data += 'contrail::params::core_mask: "%s"\n' %( - provision_params.get('core_mask', DEFAULT_CORE_MASK)) - - - - data += self.add_contrail_upgrade(server, provision_params) - - role_ips = {} - role_ids = {} - role_passwd = {} - role_users = {} - # Set enable_provision_complete flag to false - if sequence_provisioning_available and sequence_provisioning: - data += 'contrail::params::enable_post_provision: False\n' - data += 'contrail::params::enable_pre_exec_vnc_galera: False\n' - data += 'contrail::params::enable_post_exec_vnc_galera: False\n' - data += 'contrail::params::enable_keepalived: False\n' - data += 'contrail::params::enable_haproxy: False\n' - data += 'contrail::params::enable_sequence_provisioning: True\n' - data += 'contrail::params::enable_provision_started: True\n' - for role in ['database', 'config', 'openstack', - 'control', 'collector', - 'webui', 'compute', 'tsn', 'toragent']: - # Set all module enable flags to false - if sequence_provisioning_available and sequence_provisioning: - data += 'contrail::params::enable_%s: False\n' %(role) - role_ips[role] = [ - self.get_control_ip(provision_params, x["ip_address"].encode('ascii')) \ - for x in cluster_servers if role in set(eval(x['roles']))] - data += 'contrail::params::%s_ip_list: %s\n' %( - role, str(role_ips[role])) - role_ids[role] = [ - x["id"].encode('ascii') for x in cluster_servers if role in set(eval(x['roles']))] - data += 'contrail::params::%s_name_list: %s\n' %( - role, str(role_ids[role])) - role_passwd[role] = [ - x["password"].encode('ascii') for x in cluster_servers if role in set(eval(x['roles']))] - data += 'contrail::params::%s_passwd_list: %s\n' %( - role, str(role_passwd[role])) - role_users[role] = [ - "root".encode('ascii') for x in cluster_servers if role in set(eval(x['roles']))] - data += 'contrail::params::%s_user_list: %s\n' %( - role, str(role_users[role])) - - if (server['id'] == role_ids['openstack'][0]) : - data += 'contrail::params::sync_db: %s\n' %( - "True") - else: - data += 'contrail::params::sync_db: %s\n' %( - "False") - - - # Retrieve and add all the cluster parameters specified. - data += self.add_cluster_parameters(cluster_params) - # Handle any other additional parameters to be added to yaml file. - # openstack_mgmt_ip_list - openstack_mgmt_ip_list = [x["ip_address"].encode('ascii') \ - for x in cluster_servers if "openstack" in set(eval(x['roles']))] - data += 'contrail::params::openstack_mgmt_ip_list: %s\n' %( - str(openstack_mgmt_ip_list)) - # host_non_mgmt_ip - server_mgmt_ip = server.get("ip_address", "").encode('ascii') - server_control_ip = self.get_control_ip( - provision_params, server_mgmt_ip) - if (server_control_ip != server_mgmt_ip): - data += 'contrail::params::host_non_mgmt_ip: "%s"\n' %( - server_control_ip) - # host_non_mgmt_gateway - control_intf_dict = provision_params.get("control_net", "") - if control_intf_dict: - server_control_intf = eval(control_intf_dict.get(server_mgmt_ip, "")) - if server_control_intf: - intf_name, intf_details = server_control_intf.popitem() - data += 'contrail::params::host_non_mgmt_gateway: "%s"\n' %( - intf_details.get("gateway", "")) - # end if server_control_intf - # end if control_intf_dict - # enf if server_control_ip... - - data += 'contrail::params::host_roles: %s\n' %(str(provision_params['host_roles'])) - if 'toragent' in provision_params['host_roles'] : - tor_config = provision_params.get("tor_ha_config", "") - data += 'contrail::params::tor_ha_config:\n' - for host_tor_config in tor_config.keys(): - data += ' %s:\n' %(host_tor_config) - switch_list = tor_config[host_tor_config].get('switches', "") - tsn_ip = tor_config[host_tor_config].get('tsn_ip', "") - if switch_list: - for switch in switch_list: - data += ' %s%s:\n' %(switch['switch_name'],switch['id']) - data += ' tsn_ip: "%s"\n' % (tsn_ip) - for key,value in switch.items(): - data += ' %s: "%s"\n' % (key,value) - if key == 'ovs_protocol' and value.lower() == 'pssl': - self.generate_tor_certs( - switch, provision_params['server_id'], - provision_params['domain']) - #end pssl condition - #end key,value for loop - #end switch for loop - #end switch_list if condition - #end tor_config loop - #end toragent in host_roles - - if 'storage-compute' in provision_params['host_roles'] or 'storage-master' in provision_params['host_roles']: - ## Storage code - if sequence_provisioning_available and sequence_provisioning: - data += 'contrail::params::enable_storage_master: False\n' - data += 'contrail::params::enable_storage_compute: False\n' - data += 'contrail::params::storage_num_osd: %s\n' %(provision_params['storage_num_osd']) - data += 'contrail::params::storage_fsid: "%s"\n' %(provision_params['storage_fsid']) - data += 'contrail::params::storage_num_hosts: %s\n' %(provision_params['num_storage_hosts']) - data += 'contrail::params::storage_virsh_uuid: "%s"\n' %(provision_params['storage_virsh_uuid']) - data += 'contrail::params::storage_monitor_secret: "%s"\n' %(provision_params['storage_mon_secret']) - data += 'contrail::params::storage_admin_key: "%s"\n' %(provision_params['admin_key']) - data += 'contrail::params::osd_bootstrap_key: "%s"\n' %(provision_params['osd_bootstrap_key']) - data += 'contrail::params::storage_enabled: "%s"\n' %(provision_params['contrail-storage-enabled']) - data += 'contrail::params::live_migration_storage_scope: "%s"\n' %(provision_params['live_migration_storage_scope']) - data += 'contrail::params::live_migration_host: "%s"\n' %(provision_params['live_migration_host']) - data += 'contrail::params::live_migration_ip: "%s"\n' %(provision_params['live_migration_ip']) - data += 'contrail::params::storage_ip_list: %s\n' %(str(provision_params['storage_monitor_hosts'])) - - storage_mon_hosts = '' - for key in provision_params['storage_monitor_hosts']: - storage_mon_hosts += '''%s, ''' % key - data += 'contrail::params::storage_monitor_hosts: %s\n' %(str(provision_params['storage_monitor_hosts'])) - - storage_hostnames = '' - for key in provision_params['storage_hostnames']: - storage_hostnames += ''''%s', ''' % key - data += 'contrail::params::storage_hostnames: "[%s]"\n' %(str(storage_hostnames)) - - if 'storage-master' in provision_params['host_roles']: - storage_chassis_config = '' - for key in provision_params['storage_chassis_config']: - storage_chassis_config += '''"%s", ''' % key - if len(str(storage_chassis_config)) != 0: - data += 'contrail::params::storage_chassis_config: [%s]\n' %(str(storage_chassis_config)) - - if 'storage_server_disks' in provision_params: - storage_disks = [ x.encode('ascii') for x in provision_params['storage_server_disks']] - data += 'contrail::params::storage_osd_disks: %s\n' %(str(storage_disks)) - else: - data += 'contrail::params::storage_osd_disks: []\n' - control_network = self.storage_get_control_network_mask(provision_params, server, cluster) - self._smgr_log.log(self._smgr_log.DEBUG, "control-net : %s" %(control_network)) - data += 'contrail::params::storage_cluster_network: %s\n' %(control_network) - - with open(hiera_filename, "w") as site_fh: - site_fh.write(data) - # end with - # end def build_contrail_hiera_file - # Function to change key name from new param key name to pre-3.0 puppet hiera names. def xlate_key_to_pre_3_0(self, long_key, key): xlate_dict = { @@ -738,100 +425,6 @@ def build_contrail_hiera_file_new( hiera_fh.write(data) # end def build_contrail_hiera_file_new - # Use template to prepare hiera data file for openstack modules. Revisit later to refine. - 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() - # end def build_openstack_hiera_file - #generate random string def random_string(self, string_length=10): """Returns a random string of length string_length.""" @@ -857,15 +450,12 @@ def build_hiera_files( self.build_contrail_hiera_file_new( contrail_hiera_file, server, cluster, cluster_servers, package) - else: - self.build_contrail_hiera_file( - contrail_hiera_file, provision_params, server, - cluster, cluster_servers) - openstack_hiera_file = hieradata_dir + server_fqdn + \ - "-openstack.yaml" - self.build_openstack_hiera_file( - openstack_hiera_file, provision_params, server, - cluster, cluster_servers) + # Check and add contrail-defaults.yaml + contrail_defaults_file = hieradata_dir + "contrail-defaults.yaml" + contrail_defaults_source = "/etc/contrail_smgr/contrail-defaults.yaml" + if not os.path.exists(contrail_defaults_file) and os.path.exists(contrail_defaults_source): + shutil.copy(contrail_defaults_source, contrail_defaults_file) + # end def build_hieradata_files def modify_server_hiera_data(self, server_id, hiera_file, role_steps_list,