def prompt_for_language_name(language_names_to_display, module_name=None): """ Method prompts the customer to select a platform name in the interactive flow. :param language_names_to_display: A list of platform names to ask the customer to pick from. e.g. 1. Node.js 2. PHP 3. Docker 4. ... :param module_name: In case of a multi-module application, the name of the module the present selection of platform is for. :return: A string representing the platform the customer picked in the interactive flow """ chosen_solution_stack = detect_platform() if not chosen_solution_stack: io.echo() if not module_name: io.echo(prompts['platform.prompt']) else: io.echo(prompts['platform.prompt.withmodule'].replace('{module_name}', module_name)) chosen_solution_stack = utils.prompt_for_item_in_list(language_names_to_display) return chosen_solution_stack
def prompt_customer_for_custom_platform_version(version_to_arn_mappings): custom_platform_versions_to_display = sorted(version_to_arn_mappings.keys()) io.echo() io.echo(prompts['sstack.version']) chosen_custom_platform_version = utils.prompt_for_item_in_list(custom_platform_versions_to_display) return version_to_arn_mappings[chosen_custom_platform_version]
def _get_application_name_interactive(): app_list = commonops.get_application_names() file_name = fileoperations.get_current_directory_name() new_app = False if len(app_list) > 0: io.echo() io.echo('Select an application to use') new_app_option = '[ Create new Application ]' app_list.append(new_app_option) try: default_option = app_list.index(file_name) + 1 except ValueError: default_option = len(app_list) app_name = utils.prompt_for_item_in_list(app_list, default=default_option) if app_name == new_app_option: new_app = True if len(app_list) == 0 or new_app: io.echo() io.echo('Enter Application Name') unique_name = utils.get_unique_name(file_name, app_list) app_name = io.prompt_for_unique_name(unique_name, app_list) return app_name
def get_shared_lb_port_from_customer(interactive, selected_lb): """ Method accepts load balancer ARN Prompt customer to select port from list of listener port return: selected listener port """ if not interactive or selected_lb is None: return result = elbv2.get_listeners_for_load_balancer(selected_lb) listener_list = [listener['Port'] for listener in result['Listeners']] listener_list.sort() default_listener_index = listener_list.index( 80) + 1 if 80 in listener_list else None if len(listener_list) < 1: raise NotFoundError(alerts['sharedlb.listener']) elif len(listener_list) == 1: selected_listener_port = listener_list[0] else: io.echo(prompts['sharedlb.listener_prompt']) selected_listener_port = utils.prompt_for_item_in_list( listener_list, default=default_listener_index) return selected_listener_port
def get_platform_name_and_version_interactive(): platforms = get_platforms(owner=Constants.OWNED_BY_SELF, platform_version="latest") platform_list = list(platforms) file_name = fileoperations.get_current_directory_name() new_platform = False version = None if len(platform_list) > 0: io.echo() io.echo('Select a platform to use') new_platform_option = '[ Create new Platform ]' platform_list.append(new_platform_option) try: default_option = platform_list.index(file_name) + 1 except ValueError: default_option = len(platform_list) platform_name = utils.prompt_for_item_in_list(platform_list, default=default_option) if platform_name == new_platform_option: new_platform = True else: version = platforms[platform_name] if len(platform_list) == 0 or new_platform: io.echo() io.echo('Enter Platform Name') unique_name = utils.get_unique_name(file_name, platform_list) platform_name = io.prompt_for_unique_name(unique_name, platform_list) return platform_name, version
def pull_down_app_info(app_name, default_env=None): envs = elasticbeanstalk.get_app_environments(app_name) if len(envs) == 0: set_environment_for_current_branch(None) return None, None elif len(envs) == 1: env = envs[0] io.log_info('Setting only environment "' + env.name + '" as default') elif len(envs) > 1: if default_env: if default_env == '/ni': env = envs[0] else: env = next((env for env in envs if env.name == default_env), None) if not default_env or env is None: io.echo(prompts['init.selectdefaultenv']) env = utils.prompt_for_item_in_list(envs) set_environment_for_current_branch(env.name) io.log_info('Pulling down defaults from environment ' + env.name) keyname = elasticbeanstalk.get_specific_configuration_for_env( app_name, env.name, 'aws:autoscaling:launchconfiguration', 'EC2KeyName' ) if keyname is None: keyname = -1 return env.platform.arn, keyname
def _get_application_name_interactive(): app_list = elasticbeanstalk.get_application_names() file_name = fileoperations.get_current_directory_name() new_app = False if len(app_list) > 0: io.echo() io.echo('Select an application to use') new_app_option = '[ Create new Application ]' app_list.append(new_app_option) try: default_option = app_list.index(file_name) + 1 except ValueError: default_option = len(app_list) app_name = utils.prompt_for_item_in_list(app_list, default=default_option) if app_name == new_app_option: new_app = True if len(app_list) == 0 or new_app: io.echo() io.echo('Enter Application Name') unique_name = utils.get_unique_name(file_name, app_list) app_name = io.prompt_for_unique_name(unique_name, app_list) return app_name
def get_platform_name_and_version_interactive(): platforms = get_platforms(owner=Constants.OWNED_BY_SELF, platform_version="latest") platform_list = list(platforms) file_name = fileoperations.get_current_directory_name() new_platform = False version = None if len(platform_list) > 0: io.echo() io.echo('Select a platform to use') new_platform_option = '[ Create new Platform ]' platform_list.append(new_platform_option) try: default_option = platform_list.index(file_name) + 1 except ValueError: default_option = len(platform_list) platform_name = utils.prompt_for_item_in_list(platform_list, default=default_option) if platform_name == new_platform_option: new_platform = True else: version = platforms[platform_name] if len(platform_list) == 0 or new_platform: io.echo() io.echo('Enter Platform Name') unique_name = utils.get_unique_name(file_name, platform_list) platform_name = io.prompt_for_unique_name(unique_name, platform_list) return platform_name, version
def prompt_for_ec2_keyname(env_name=None, message=None, keyname=None): if message is None: message = prompts['ssh.setup'] if env_name: io.validate_action(prompts['terminate.validate'], env_name) else: io.echo(message) ssh = io.get_boolean_response() if not ssh: return None keys = [k['KeyName'] for k in ec2.get_key_pairs()] default_option = len(keys) if keyname: for index, key in enumerate(keys): if key == keyname: default_option = index + 1 if len(keys) < 1: keyname = _generate_and_upload_keypair(keys) else: new_key_option = '[ Create new KeyPair ]' keys.append(new_key_option) io.echo() io.echo(prompts['keypair.prompt']) keyname = utils.prompt_for_item_in_list(keys, default=default_option) if keyname == new_key_option: keyname = _generate_and_upload_keypair(keys) return keyname
def prompt_customer_for_custom_platform_version(version_to_arn_mappings): custom_platform_versions_to_display = sorted(version_to_arn_mappings.keys()) io.echo() io.echo(prompts['sstack.version']) chosen_custom_platform_version = utils.prompt_for_item_in_list(custom_platform_versions_to_display) return version_to_arn_mappings[chosen_custom_platform_version]
def get_elb_type_from_customer(interactive, single, tier): """ Prompt customer to specify the ELB type if operating in the interactive mode and on a load-balanced environment. Selection defaults to 'application' when provided with blank input. :param interactive: True/False depending on whether operating in the interactive mode or not :param single: False/True depending on whether environment is load balanced or not :param region: AWS region in which in load balancer will be created :param tier: the tier type of the environment :return: selected ELB type which is one among ['application', 'classic', 'network'] """ if single or (tier and not tier.is_webserver()): return elif not interactive: return elb_names.APPLICATION_VERSION io.echo() io.echo('Select a load balancer type') result = utils.prompt_for_item_in_list([ elb_names.CLASSIC_VERSION, elb_names.APPLICATION_VERSION, elb_names.NETWORK_VERSION ], default=2) elb_type = result return elb_type
def get_branch_interactive(repository): source_control = SourceControl.get_source_control() # Give list of code commit branches to use new_branch = False branch_list = codecommit.list_branches(repository)["branches"] current_branch = source_control.get_current_branch() # If there are existing branches prompt the user to pick one if len(branch_list) > 0: io.echo('Select a branch') new_branch_option = '[ Create new Branch with local HEAD ]' branch_list.append(new_branch_option) try: default_option = branch_list.index(current_branch) + 1 except ValueError: default_option = len(branch_list) branch_name = utils.prompt_for_item_in_list(branch_list, default=default_option) if branch_name == new_branch_option: new_branch = True # Create a new branch if the user specifies or there are no existing branches if len(branch_list) == 0 or new_branch: new_branch = True io.echo() io.echo('Enter Branch Name') io.echo( '***** Must have at least one commit to create a new branch with CodeCommit *****' ) unique_name = utils.get_unique_name(current_branch, branch_list) branch_name = io.prompt_for_unique_name(unique_name, branch_list) # Setup git to push to this repo result = codecommit.get_repository(repository) remote_url = result['repositoryMetadata']['cloneUrlHttp'] source_control.setup_codecommit_remote_repo(remote_url=remote_url) if len(branch_list) == 0 or new_branch: LOG.debug("Creating a new branch") try: create_codecommit_branch(source_control, branch_name) except ServiceError: io.echo( "Could not set CodeCommit branch with the current commit, run with '--debug' to get the full error" ) return None elif not new_branch: LOG.debug("Setting up an existing branch") succesful_branch = source_control.setup_existing_codecommit_branch( branch_name, remote_url) if not succesful_branch: io.echo( "Could not set CodeCommit branch, run with '--debug' to get the full error" ) return None return branch_name
def prompt_for_codesource(self): gitops.print_current_codecommit_settings() io.echo(prompts['codesource.codesourceprompt']) setup_choices = ['CodeCommit', 'Local'] choice = utils.prompt_for_item_in_list(setup_choices, 2) if choice == setup_choices[0]: self.set_codecommit() elif choice == setup_choices[1]: self.set_local()
def test_prompt_for_item_in_list__with_default( self, prompt_for_index_in_list_mock, ): lst = ['a', 'b', 'c'] prompt_for_index_in_list_mock.return_value = 2 result = utils.prompt_for_item_in_list(lst, default=2) prompt_for_index_in_list_mock.assert_called_once_with(lst, 2) self.assertEqual('c', result)
def get_branch_interactive(repository): source_control = SourceControl.get_source_control() # Give list of code commit branches to use new_branch = False branch_list = codecommit.list_branches(repository)["branches"] current_branch = source_control.get_current_branch() # If there are existing branches prompt the user to pick one if len(branch_list) > 0: io.echo('Select a branch') new_branch_option = '[ Create new Branch with local HEAD ]' branch_list.append(new_branch_option) try: default_option = branch_list.index(current_branch) + 1 except ValueError: default_option = len(branch_list) branch_name = utils.prompt_for_item_in_list(branch_list, default=default_option) if branch_name == new_branch_option: new_branch = True # Create a new branch if the user specifies or there are no existing branches if len(branch_list) == 0 or new_branch: new_branch = True io.echo() io.echo('Enter Branch Name') io.echo('***** Must have at least one commit to create a new branch with CodeCommit *****') unique_name = utils.get_unique_name(current_branch, branch_list) branch_name = io.prompt_for_unique_name(unique_name, branch_list) # Setup git to push to this repo result = codecommit.get_repository(repository) remote_url = result['repositoryMetadata']['cloneUrlHttp'] source_control.setup_codecommit_remote_repo(remote_url=remote_url) if len(branch_list) == 0 or new_branch: LOG.debug("Creating a new branch") try: create_codecommit_branch(source_control, branch_name) except ServiceError: io.echo("Could not set CodeCommit branch with the current commit, run with '--debug' to get the full error") return None elif not new_branch: LOG.debug("Setting up an existing branch") succesful_branch = source_control.setup_existing_codecommit_branch(branch_name, remote_url) if not succesful_branch: io.echo("Could not set CodeCommit branch, run with '--debug' to get the full error") return None return branch_name
def prompt_for_platform_family(include_custom=False): families = list_nonretired_platform_families() families.sort() detected_platform_family = detect_platform_family(families) if detected_platform_family: return detected_platform_family if include_custom: families.append(prompts['platformfamily.prompt.customplatform']) io.echo(prompts['platformfamily.prompt']) return utils.prompt_for_item_in_list(families, default=None)
def prepare_for_ssh(env_name, instance, keep_open, force, setup, number, keyname=None, no_keypair_error_message=None, custom_ssh=None, command=None, timeout=None): if setup: setup_ssh(env_name, keyname, timeout=timeout) return if instance and number: raise InvalidOptionsError(strings['ssh.instanceandnumber']) if not instance: instances = commonops.get_instance_ids(env_name) if number is not None: if number > len(instances) or number < 1: raise InvalidOptionsError('Invalid index number (' + str(number) + ') for environment with ' + str(len(instances)) + ' instances') else: instance = instances[number - 1] elif len(instances) == 1: instance = instances[0] else: io.echo() io.echo('Select an instance to ssh into') instance = utils.prompt_for_item_in_list(instances) try: ssh_into_instance(instance, keep_open=keep_open, force_open=force, custom_ssh=custom_ssh, command=command) except NoKeypairError: if not no_keypair_error_message: no_keypair_error_message = prompts['ssh.nokey'] io.log_error(no_keypair_error_message)
def get_region(region_argument, interactive, force_non_interactive=False): # Get region from command line arguments region = get_region_from_inputs(region_argument) # Ask for region if (not region) and force_non_interactive: # Choose defaults region_list = regions.get_all_regions() region = region_list[2].name if not region or (interactive and not region_argument): io.echo() io.echo('Select a default region') region_list = regions.get_all_regions() result = utils.prompt_for_item_in_list(region_list, default=3) region = result.name return region
def get_region(region_argument, interactive, force_non_interactive=False): # Get region from command line arguments region = get_region_from_inputs(region_argument) # Ask for region if (not region) and force_non_interactive: # Choose defaults region_list = regions.get_all_regions() region = region_list[2].name if not region or (interactive and not region_argument): io.echo() io.echo('Select a default region') region_list = regions.get_all_regions() result = utils.prompt_for_item_in_list(region_list, default=3) region = result.name return region
def do_command(self): app_name = self.get_app_name() source_env = self.get_env_name() destination_env = self.app.pargs.destination_name if not destination_env: envs = elasticbeanstalk.get_environment_names(app_name) if len(envs) < 2: raise NotSupportedError(strings['swap.unsupported']) envs = [e for e in envs if e != source_env] if len(envs) == 1: destination_env = envs[0] else: io.echo() io.echo(prompts['swap.envprompt']) destination_env = utils.prompt_for_item_in_list(envs) swapops.cname_swap(source_env, destination_env)
def get_region(self): # Get region from command line arguments region = self.get_region_from_inputs() # Ask for region if (not region) and self.force_non_interactive: # Choose defaults region_list = regions.get_all_regions() region = region_list[2].name if not region or \ (self.interactive and not self.app.pargs.region): io.echo() io.echo('Select a default region') region_list = regions.get_all_regions() result = utils.prompt_for_item_in_list(region_list, default=3) region = result.name return region
def prompt_for_solution_stack_version(matching_language_versions): """ Method prompts customer to pick a solution stack version, given a set of platform versions of a language :param matching_language_versions: A list of platform versions of a language to allow the customer to choose from. e.g. Given Platform, Ruby, the following options will be presented 1. Ruby 2.4 (Passenger standalone) 2. Ruby 2.4 (Puma) 3. ... :return: A string representing te platform version the customer would like to use. """ io.echo() io.echo(prompts['sstack.version']) language_versions_to_display = [version['PlatformShorthand'] for version in matching_language_versions] return utils.prompt_for_item_in_list(language_versions_to_display)
def ssh(self): aws.set_region(self.region) aws.set_profile(self.profile) if self.environment_name is None: environment_names = get_all_environment_names() if environment_names: error = "Please chose one of the following environment names:\n\n" error += "\n".join(sorted(environment_names)) + "\n" io.log_error(error) else: io.log_error( "The current Elastic Beanstalk application has no environments" ) sys.exit() instances = get_instance_ids(self.environment_name) if len(instances) == 1: instance = instances[0] else: io.echo() io.echo('Select an instance to ssh into') instance = utils.prompt_for_item_in_list(instances) params = [ "aws", "ssm", "start-session", "--document-name", "AWS-StartInteractiveCommand", "--parameters", "command='bash -l'", "--profile", self.profile, "--region", self.region, "--target", instance, ] os.system(" ".join(params))
def get_repository_interactive(): source_control = SourceControl.get_source_control() # Give list of code commit repositories to use new_repo = False repo_list = codecommit.list_repositories()["repositories"] current_repository = source_control.get_current_repository() current_repository = fileoperations.get_current_directory_name() \ if current_repository is None else current_repository # If there are existing repositories prompt the user to pick one # otherwise set default as the file name if len(repo_list) > 0: repo_list = list(map(lambda r: r["repositoryName"], repo_list)) io.echo() io.echo('Select a repository') new_repo_option = '[ Create new Repository ]' repo_list.append(new_repo_option) try: default_option = repo_list.index(current_repository) + 1 except ValueError: default_option = len(repo_list) repo_name = utils.prompt_for_item_in_list(repo_list, default=default_option) if repo_name == new_repo_option: new_repo = True # Create a new repository if the user specifies or there are no existing repositories if len(repo_list) == 0 or new_repo: io.echo() io.echo('Enter Repository Name') unique_name = utils.get_unique_name(current_repository, repo_list) repo_name = io.prompt_for_unique_name(unique_name, repo_list) # Create the repository if we get here codecommit.create_repository(repo_name, "Created with EB CLI") io.echo("Successfully created repository: {0}".format(repo_name)) return repo_name
def do_command(self): app_name = self.get_app_name() source_env = self.get_env_name() destination_env = self.app.pargs.destination_name if not destination_env: # Ask interactively for an env to swap with envs = elasticbeanstalk.get_environment_names(app_name) if len(envs) < 2: raise NotSupportedError(strings['swap.unsupported']) # Filter out current env envs = [e for e in envs if e != source_env] if len(envs) == 1: # Don't ask for env, just swap with only other environment destination_env = envs[0] else: # Ask for env to swap with io.echo() io.echo(prompts['swap.envprompt']) destination_env = utils.prompt_for_item_in_list(envs) swapops.cname_swap(source_env, destination_env)
def do_command(self): app_name = self.get_app_name() env_name = self.get_env_name(noerror=True) provided_env_name = bool(self.app.pargs.environment_name) if not provided_env_name: # Ask interactively for an env to abort envs = abortops.get_abortable_envs(app_name) if len(envs) < 1: raise NotFoundError(strings['abort.noabortableenvs']) if len(envs) == 1: # Don't ask for env, just abort only abortable environment env_name = envs[0].name else: # Ask for env to abort io.echo() io.echo(prompts['abort.envprompt']) env_name = utils.prompt_for_item_in_list(envs).name else: # Just do the abort if env_name is provided pass abortops.abort_operation(env_name)
def get_repository_interactive(): source_control = SourceControl.get_source_control() # Give list of code commit repositories to use new_repo = False repo_list = codecommit.list_repositories()["repositories"] current_repository = source_control.get_current_repository() current_repository = current_repository or fileoperations.get_current_directory_name() # If there are existing repositories prompt the user to pick one # otherwise set default as the file name if len(repo_list) > 0: repo_list = list(map(lambda r: r["repositoryName"], repo_list)) io.echo() io.echo('Select a repository') new_repo_option = '[ Create new Repository ]' repo_list.append(new_repo_option) try: default_option = repo_list.index(current_repository) + 1 except ValueError: default_option = len(repo_list) repo_name = utils.prompt_for_item_in_list(repo_list, default=default_option) if repo_name == new_repo_option: new_repo = True # Create a new repository if the user specifies or there are no existing repositories if len(repo_list) == 0 or new_repo: io.echo() io.echo('Enter Repository Name') unique_name = utils.get_unique_name(current_repository, repo_list) repo_name = io.prompt_for_unique_name(unique_name, repo_list) create_codecommit_repository(repo_name) return repo_name
def prompt_customer_for_custom_platform_name(custom_platforms): custom_platform_names_to_display = group_custom_platforms_by_platform_name( custom_platforms) return utils.prompt_for_item_in_list(custom_platform_names_to_display)
def do_command(self): app_name = self.get_app_name() env_name = self.get_env_name() clone_name = self.app.pargs.clone_name cname = self.app.pargs.cname scale = self.app.pargs.scale nohang = self.app.pargs.nohang tags = self.app.pargs.tags envvars = self.app.pargs.envvars exact = self.app.pargs.exact timeout = self.app.pargs.timeout provided_clone_name = clone_name is not None platform = None env = elasticbeanstalk.get_environment(app_name=app_name, env_name=env_name) tier = env.tier if 'worker' in tier.name.lower() and cname: raise InvalidOptionsError(strings['worker.cname']) if cname: if not elasticbeanstalk.is_cname_available(cname): raise AlreadyExistsError(strings['cname.unavailable'].replace( '{cname}', cname)) tags = tagops.get_and_validate_tags(tags) envvars = get_and_validate_envars(envvars) if not clone_name: if len(env_name) < 16: unique_name = env_name + '-clone' else: unique_name = 'my-cloned-env' env_list = elasticbeanstalk.get_environment_names(app_name) unique_name = utils.get_unique_name(unique_name, env_list) clone_name = io.prompt_for_environment_name( default_name=unique_name, prompt_text='Enter name for Environment Clone') if tier.name.lower() == 'webserver': if not cname and not provided_clone_name: cname = get_cname_from_customer(clone_name) elif not cname: cname = None if not exact: if not provided_clone_name: latest = solution_stack_ops.find_solution_stack_from_string( env.platform.name, find_newer=True) if latest != env.platform: io.echo() io.echo(prompts['clone.latest']) lst = [ 'Latest (' + str(latest) + ')', 'Same (' + str(env.platform) + ')' ] result = utils.prompt_for_item_in_list(lst) if result == lst[0]: platform = latest else: platform = latest else: platform = solution_stack_ops.find_solution_stack_from_string( env.platform.name, find_newer=True) if platform != env.platform: io.log_warning(prompts['clone.latestwarn']) clone_request = CloneEnvironmentRequest( app_name=app_name, env_name=clone_name, original_name=env_name, cname=cname, platform=platform, scale=scale, tags=tags, ) clone_request.option_settings += envvars cloneops.make_cloned_env(clone_request, nohang=nohang, timeout=timeout)
def get_branch_interactive(repository): source_control = SourceControl.get_source_control() # Give list of code commit branches to use new_branch = False branch_list = codecommit.list_branches(repository)["branches"] current_branch = source_control.get_current_branch() # If there are existing branches prompt the user to pick one if len(branch_list) > 0: io.echo() io.echo('Select a branch') new_branch_option = '[ Create new Branch with local HEAD ]' branch_list.append(new_branch_option) try: default_option = branch_list.index(current_branch) + 1 except ValueError: default_option = len(branch_list) branch_name = utils.prompt_for_item_in_list(branch_list, default=default_option) if branch_name == new_branch_option: new_branch = True # Create a new branch if the user specifies or there are no existing branches current_commit = source_control.get_current_commit() if len(branch_list) == 0 or new_branch: new_branch = True io.echo() io.echo('Enter Branch Name') io.echo( '***** Must have at least one commit to create a new branch with CodeCommit *****' ) unique_name = utils.get_unique_name(current_branch, branch_list) branch_name = io.prompt_for_unique_name(unique_name, branch_list) # Setup git to push to this repo result = codecommit.get_repository(repository) source_control.setup_codecommit_remote_repo( remote_url=result['repositoryMetadata']['cloneUrlHttp']) if len(branch_list) == 0 or new_branch: LOG.debug("Creating a new branch") try: # Creating the branch requires that we setup the remote branch first # to ensure the code commit branch is synced with the local branch if current_commit is None: # TODO: Test on windows for weird empty returns with the staged files staged_files = source_control.get_list_of_staged_files() if staged_files is None or not staged_files: source_control.create_initial_commit() else: LOG.debug( "Cannot create placeholder commit because there are staged files: {0}" .format(staged_files)) io.echo( "Could not set create a commit with staged files; cannot setup CodeCommit branch without a commit" ) return None current_commit = source_control.get_current_commit() source_control.setup_new_codecommit_branch(branch_name=branch_name) codecommit.create_branch(repository, branch_name, current_commit) io.echo("Successfully created branch: {0}".format(branch_name)) except ServiceError: io.echo( "Could not set CodeCommit branch with the current commit, run with '--debug' to get the full error" ) return None elif not new_branch: LOG.debug("Setting up an existing branch") succesful_branch = source_control.setup_existing_codecommit_branch( branch_name) if not succesful_branch: io.echo( "Could not set CodeCommit branch, run with '--debug' to get the full error" ) return None return branch_name
def prompt_customer_for_custom_platform_name(custom_platforms): custom_platform_names_to_display = group_custom_platforms_by_platform_name(custom_platforms) return utils.prompt_for_item_in_list(custom_platform_names_to_display)