from pathlib import Path from typing import Optional, List from typer import launch as typer_launch from phi.cli.settings import phi_cli_settings, PHI_CLI_DIR from phi.cli.config import PhiCliConfig from phi.cli.console import print_info, print_heading from phi.infra.type import InfraType from phi.infra.resources import InfraResources from phi.utils.log import logger def delete_phidata_conf() -> None: from phi.utils.filesystem import delete_from_fs logger.debug("Removing existing Phidata configuration") delete_from_fs(PHI_CLI_DIR) def authenticate_user() -> None: """Authenticate the user using credentials from phidata.com Steps: 1. Authenticate the user by opening the phidata sign-in url and the web-app will post an auth token to a mini http server running on the auth_server_port. 2. Using the auth_token, authenticate the CLI with api and save the auth_token. This step is handled by authenticate_and_get_user() 3. After the user is authenticated update the PhiCliConfig. """ from phi.api.user import authenticate_and_get_user from phi.api.schemas.user import UserSchema from phi.cli.auth_server import ( get_port_for_auth_server, get_auth_token_from_web_flow, ) print_heading("Authenticating with phidata.com ...") auth_server_port = get_port_for_auth_server() redirect_uri = "http%3A%2F%2Flocalhost%3A{}%2F".format(auth_server_port) auth_url = "{}?source=cli&action=signin&redirecturi={}".format(phi_cli_settings.signin_url, redirect_uri) print_info("\nYour browser will be opened to visit:\n{}".format(auth_url)) typer_launch(auth_url) print_info("\nWaiting for a response from browser...\n") tmp_auth_token = get_auth_token_from_web_flow(auth_server_port) if tmp_auth_token is None: logger.error("Could not authenticate, please try again") return phi_config: Optional[PhiCliConfig] = PhiCliConfig.from_saved_config() existing_user: Optional[UserSchema] = phi_config.user if phi_config is not None else None try: user: Optional[UserSchema] = authenticate_and_get_user( tmp_auth_token=tmp_auth_token, existing_user=existing_user ) except Exception as e: logger.exception(e) logger.error("Could not authenticate, please try again") return if user is None: logger.error("Could not authenticate, please try again") return if phi_config is None: phi_config = PhiCliConfig(user) phi_config.save_config() else: phi_config.user = user print_info("Welcome {}".format(user.email)) def initialize_phi(reset: bool = False, login: bool = False) -> bool: """Initialize phi on the users machine. Steps: 1. Check if PHI_CLI_DIR exists, if not, create it. If reset == True, recreate PHI_CLI_DIR. 2. Authenticates the user if login == True. 3. If PhiCliConfig exists and auth is valid, return True. """ from phi.utils.filesystem import delete_from_fs from phi.api.user import create_anon_user print_heading("Welcome to phidata!") if reset: delete_phidata_conf() logger.debug("Initializing phidata") # Check if ~/.phi exists, if it is not a dir - delete it and create the dir if PHI_CLI_DIR.exists(): logger.debug(f"{PHI_CLI_DIR} exists") if not PHI_CLI_DIR.is_dir(): try: delete_from_fs(PHI_CLI_DIR) except Exception as e: logger.exception(e) raise Exception(f"Something went wrong, please delete {PHI_CLI_DIR} and run again") PHI_CLI_DIR.mkdir(parents=True, exist_ok=True) else: PHI_CLI_DIR.mkdir(parents=True) logger.debug(f"Created {PHI_CLI_DIR}") # Confirm PHI_CLI_DIR exists otherwise we should return if PHI_CLI_DIR.exists(): logger.debug(f"Phidata config location: {PHI_CLI_DIR}") else: raise Exception("Something went wrong, please try again") phi_config: Optional[PhiCliConfig] = PhiCliConfig.from_saved_config() if phi_config is None: logger.debug("Creating new PhiCliConfig") phi_config = PhiCliConfig() phi_config.save_config() # Authenticate user if login: authenticate_user() else: anon_user = create_anon_user() if anon_user is not None and phi_config is not None: phi_config.user = anon_user if phi_config is not None: logger.debug("Phidata initialized") return True else: logger.error("Something went wrong, please try again") return False def sign_in_using_cli() -> None: from getpass import getpass from phi.api.user import sign_in_user from phi.api.schemas.user import UserSchema, EmailPasswordAuthSchema print_heading("Log in") email_raw = input("email: ") pass_raw = getpass() if email_raw is None or pass_raw is None: logger.error("Incorrect email or password") try: user: Optional[UserSchema] = sign_in_user(EmailPasswordAuthSchema(email=email_raw, password=pass_raw)) except Exception as e: logger.exception(e) logger.error("Could not authenticate, please try again") return if user is None: logger.error("Could not get user, please try again") return phi_config: Optional[PhiCliConfig] = PhiCliConfig.from_saved_config() if phi_config is None: phi_config = PhiCliConfig(user) phi_config.save_config() else: phi_config.user = user print_info("Welcome {}".format(user.email)) def start_resources( phi_config: PhiCliConfig, resources_file_path: Path, target_env: Optional[str] = None, target_infra: Optional[InfraType] = None, target_group: Optional[str] = None, target_name: Optional[str] = None, target_type: Optional[str] = None, dry_run: Optional[bool] = False, auto_confirm: Optional[bool] = False, force: Optional[bool] = None, pull: Optional[bool] = False, ) -> None: print_heading(f"Starting resources in: {resources_file_path}") logger.debug(f"\ttarget_env : {target_env}") logger.debug(f"\ttarget_infra : {target_infra}") logger.debug(f"\ttarget_name : {target_name}") logger.debug(f"\ttarget_type : {target_type}") logger.debug(f"\ttarget_group : {target_group}") logger.debug(f"\tdry_run : {dry_run}") logger.debug(f"\tauto_confirm : {auto_confirm}") logger.debug(f"\tforce : {force}") logger.debug(f"\tpull : {pull}") from phi.workspace.config import WorkspaceConfig if not resources_file_path.exists(): logger.error(f"File does not exist: {resources_file_path}") return # Get resource groups to deploy resource_groups_to_create: List[InfraResources] = WorkspaceConfig.get_resources_from_file( resource_file=resources_file_path, env=target_env, infra=target_infra, order="create", ) # Track number of resource groups created num_rgs_created = 0 num_rgs_to_create = len(resource_groups_to_create) # Track number of resources created num_resources_created = 0 num_resources_to_create = 0 if num_rgs_to_create == 0: print_info("No resources to create") return logger.debug(f"Deploying {num_rgs_to_create} resource groups") for rg in resource_groups_to_create: _num_resources_created, _num_resources_to_create = rg.create_resources( group_filter=target_group, name_filter=target_name, type_filter=target_type, dry_run=dry_run, auto_confirm=auto_confirm, force=force, pull=pull, ) if _num_resources_created > 0: num_rgs_created += 1 num_resources_created += _num_resources_created num_resources_to_create += _num_resources_to_create logger.debug(f"Deployed {num_resources_created} resources in {num_rgs_created} resource groups") if dry_run: return if num_resources_created == 0: return print_heading(f"\n--**-- ResourceGroups deployed: {num_rgs_created}/{num_rgs_to_create}\n") if num_resources_created != num_resources_to_create: logger.error("Some resources failed to create, please check logs") def stop_resources( phi_config: PhiCliConfig, resources_file_path: Path, target_env: Optional[str] = None, target_infra: Optional[InfraType] = None, target_group: Optional[str] = None, target_name: Optional[str] = None, target_type: Optional[str] = None, dry_run: Optional[bool] = False, auto_confirm: Optional[bool] = False, force: Optional[bool] = None, ) -> None: print_heading(f"Stopping resources in: {resources_file_path}") logger.debug(f"\ttarget_env : {target_env}") logger.debug(f"\ttarget_infra : {target_infra}") logger.debug(f"\ttarget_name : {target_name}") logger.debug(f"\ttarget_type : {target_type}") logger.debug(f"\ttarget_group : {target_group}") logger.debug(f"\tdry_run : {dry_run}") logger.debug(f"\tauto_confirm : {auto_confirm}") logger.debug(f"\tforce : {force}") from phi.workspace.config import WorkspaceConfig if not resources_file_path.exists(): logger.error(f"File does not exist: {resources_file_path}") return # Get resource groups to shutdown resource_groups_to_shutdown: List[InfraResources] = WorkspaceConfig.get_resources_from_file( resource_file=resources_file_path, env=target_env, infra=target_infra, order="create", ) # Track number of resource groups deleted num_rgs_shutdown = 0 num_rgs_to_shutdown = len(resource_groups_to_shutdown) # Track number of resources created num_resources_shutdown = 0 num_resources_to_shutdown = 0 if num_rgs_to_shutdown == 0: print_info("No resources to delete") return logger.debug(f"Deleting {num_rgs_to_shutdown} resource groups") for rg in resource_groups_to_shutdown: _num_resources_shutdown, _num_resources_to_shutdown = rg.delete_resources( group_filter=target_group, name_filter=target_name, type_filter=target_type, dry_run=dry_run, auto_confirm=auto_confirm, force=force, ) if _num_resources_shutdown > 0: num_rgs_shutdown += 1 num_resources_shutdown += _num_resources_shutdown num_resources_to_shutdown += _num_resources_to_shutdown logger.debug(f"Deleted {num_resources_shutdown} resources in {num_rgs_shutdown} resource groups") if dry_run: return if num_resources_shutdown == 0: return print_heading(f"\n--**-- ResourceGroups deleted: {num_rgs_shutdown}/{num_rgs_to_shutdown}\n") if num_resources_shutdown != num_resources_to_shutdown: logger.error("Some resources failed to delete, please check logs") def patch_resources( phi_config: PhiCliConfig, resources_file_path: Path, target_env: Optional[str] = None, target_infra: Optional[InfraType] = None, target_group: Optional[str] = None, target_name: Optional[str] = None, target_type: Optional[str] = None, dry_run: Optional[bool] = False, auto_confirm: Optional[bool] = False, force: Optional[bool] = None, ) -> None: print_heading(f"Updating resources in: {resources_file_path}") logger.debug(f"\ttarget_env : {target_env}") logger.debug(f"\ttarget_infra : {target_infra}") logger.debug(f"\ttarget_name : {target_name}") logger.debug(f"\ttarget_type : {target_type}") logger.debug(f"\ttarget_group : {target_group}") logger.debug(f"\tdry_run : {dry_run}") logger.debug(f"\tauto_confirm : {auto_confirm}") logger.debug(f"\tforce : {force}") from phi.workspace.config import WorkspaceConfig if not resources_file_path.exists(): logger.error(f"File does not exist: {resources_file_path}") return # Get resource groups to update resource_groups_to_patch: List[InfraResources] = WorkspaceConfig.get_resources_from_file( resource_file=resources_file_path, env=target_env, infra=target_infra, order="create", ) num_rgs_patched = 0 num_rgs_to_patch = len(resource_groups_to_patch) # Track number of resources updated num_resources_patched = 0 num_resources_to_patch = 0 if num_rgs_to_patch == 0: print_info("No resources to patch") return logger.debug(f"Patching {num_rgs_to_patch} resource groups") for rg in resource_groups_to_patch: _num_resources_patched, _num_resources_to_patch = rg.update_resources( group_filter=target_group, name_filter=target_name, type_filter=target_type, dry_run=dry_run, auto_confirm=auto_confirm, force=force, ) if _num_resources_patched > 0: num_rgs_patched += 1 num_resources_patched += _num_resources_patched num_resources_to_patch += _num_resources_to_patch logger.debug(f"Patched {num_resources_patched} resources in {num_rgs_patched} resource groups") if dry_run: return if num_resources_patched == 0: return print_heading(f"\n--**-- ResourceGroups patched: {num_rgs_patched}/{num_rgs_to_patch}\n") if num_resources_patched != num_resources_to_patch: logger.error("Some resources failed to patch, please check logs")