Skip to content

Commit

Permalink
Closes-Bug: #1592161 - Deprecating Old Params Format for Cluster Params
Browse files Browse the repository at this point in the history 
From now on, only JSONS in new params will be accepted by SM Backend

Change-Id: Icbe9425bd0030ff604b8075c7a29c0a94f5ccf8e
  • Loading branch information
nitishkrishna committed Jun 21, 2016
1 parent 436e19b commit 63300ba
Show file tree
Hide file tree
Showing 2 changed files with 14 additions and 751 deletions.
343 changes: 8 additions & 335 deletions src/server_mgr_main.py
View file
Expand Up @@ -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):
Expand Down Expand Up @@ -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),
Expand Down Expand Up @@ -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()

Expand Down

0 comments on commit 63300ba

Please sign in to comment.