Feature/multiple profiles

README.md

@@ -1,8 +1,8 @@
 # The Code42 CLI
 
 Use the `code42` command to interact with your Code42 environment.
-`code42 securitydata` is a CLI tool for extracting AED events.
-Additionally, `code42 securitydata` can record a checkpoint so that you only get events you have not previously gotten.
+`code42 securitydata` is a CLI tool for extracting file events.
+Additionally, you can choose to only get events that Code42 previously did not observe since you last recorded a checkpoint.
 
 ## Requirements
 

src/code42cli/arguments.py

@@ -0,0 +1,25 @@
+PROFILE_NAME_KEY = u"profile_name"
+
+
+def add_arguments_to_parser(parser):
+    add_debug_arg(parser)
+    add_profile_name_arg(parser)
+
+
+def add_debug_arg(parser):
+    parser.add_argument(
+        u"-d",
+        u"--debug",
+        dest=u"is_debug_mode",
+        action=u"store_true",
+        help=u"Turn on Debug logging.",
+    )
+
+
+def add_profile_name_arg(parser):
+    parser.add_argument(
+        u"--profile",
+        action=u"store",
+        dest=PROFILE_NAME_KEY,
+        help=u"The name of the profile containing your Code42 username and authority host address.",
+    )

src/code42cli/profile/config.py

@@ -6,136 +6,189 @@
 import code42cli.util as util
 from code42cli.compat import str
 
-_DEFAULT_VALUE = u"__DEFAULT__"
+DEFAULT_VALUE = u"__DEFAULT__"
+_PROFILE_ENV_VAR_NAME = u"CODE42CLI_PROFILE"
 
 
 class ConfigurationKeys(object):
-    USER_SECTION = u"Code42"
     AUTHORITY_KEY = u"c42_authority_url"
     USERNAME_KEY = u"c42_username"
     IGNORE_SSL_ERRORS_KEY = u"ignore-ssl-errors"
     INTERNAL_SECTION = u"Internal"
-    HAS_SET_PROFILE_KEY = u"has_set_profile"
+    DEFAULT_PROFILE_IS_COMPLETE = u"default_profile_is_complete"
+    DEFAULT_PROFILE = u"default_profile"
 
 
-def get_config_profile():
-    """Get your config file profile."""
+def get_profile(profile_name=None):
+    """Gets the config file variables for the given name.
+
+        Args:
+            profile_name: The name of the profile to get variables for.
+            If None, uses the default profile name.
+    """
     parser = ConfigParser()
-    if not profile_has_been_set():
-        util.print_error(u"Profile has not completed setup.")
-        print(u"")
-        print(u"To set, use: ")
-        util.print_bold(u"\tcode42 profile set -s <authority-URL> -u <username>")
-        print(u"")
+    available_profiles = _get_all_profile_names()
+    if len(available_profiles) == 0:
+        util.print_no_existing_profile_message()
         exit(1)
 
-    return _get_config_profile_from_parser(parser)
+    if profile_name and profile_name not in available_profiles:
+        _print_profile_not_exists_message(profile_name)
+        exit(1)
 
+    if not profile_name:
+        profile_name = _get_default_profile_name()
 
-def profile_has_been_set():
-    """Whether you have, at one point in time, set your username and authority server URL."""
-    parser = ConfigParser()
-    config_file_path = _get_config_file_path()
-    parser.read(config_file_path)
-    settings = parser[ConfigurationKeys.INTERNAL_SECTION]
-    return settings.getboolean(ConfigurationKeys.HAS_SET_PROFILE_KEY)
+    return _get_profile_from_parser(parser, profile_name)
 
 
-def mark_as_set_if_complete():
-    if not _profile_can_be_set():
-        return
-    parser = ConfigParser()
-    config_file_path = _get_config_file_path()
-    parser.read(config_file_path)
-    settings = parser[ConfigurationKeys.INTERNAL_SECTION]
-    settings[ConfigurationKeys.HAS_SET_PROFILE_KEY] = u"True"
-    _save(parser, ConfigurationKeys.HAS_SET_PROFILE_KEY)
+def get_all_profiles():
+    names = _get_all_profile_names()
+    profiles = []
+    for name in names:
+        profiles.append(get_profile(name))
+    return profiles
 
 
-def set_username(new_username):
+def write_username(new_username, profile_name=None):
+    profile_name = profile_name or _get_default_profile_name()
     parser = ConfigParser()
-    profile = _get_config_profile_from_parser(parser)
+    profile = _get_profile_from_parser(parser, profile_name)
     profile[ConfigurationKeys.USERNAME_KEY] = new_username
-    _save(parser, ConfigurationKeys.USERNAME_KEY)
+    _save(parser, profile_name, ConfigurationKeys.USERNAME_KEY)
+    _try_mark_setup_as_complete(profile_name)
 
 
-def set_authority_url(new_url):
+def write_authority_url(new_url, profile_name=None):
+    profile_name = profile_name or _get_default_profile_name()
     parser = ConfigParser()
-    profile = _get_config_profile_from_parser(parser)
+    profile = _get_profile_from_parser(parser, profile_name)
     profile[ConfigurationKeys.AUTHORITY_KEY] = new_url
-    _save(parser, ConfigurationKeys.AUTHORITY_KEY)
+    _save(parser, profile_name, ConfigurationKeys.AUTHORITY_KEY)
+    _try_mark_setup_as_complete(profile_name)
 
 
-def set_ignore_ssl_errors(new_value):
+def write_ignore_ssl_errors(new_value, profile_name=None):
+    profile_name = profile_name or _get_default_profile_name()
     parser = ConfigParser()
-    profile = _get_config_profile_from_parser(parser)
+    profile = _get_profile_from_parser(parser, profile_name)
     profile[ConfigurationKeys.IGNORE_SSL_ERRORS_KEY] = str(new_value)
-    _save(parser, ConfigurationKeys.IGNORE_SSL_ERRORS_KEY)
+    _save(parser, profile_name, ConfigurationKeys.IGNORE_SSL_ERRORS_KEY)
 
 
-def _profile_can_be_set():
-    """Whether your current username and authority URL are set,
-        but your profile has not been marked as set.
-    """
+def _get_all_profile_names():
     parser = ConfigParser()
-    profile = _get_config_profile_from_parser(parser)
-    username = profile[ConfigurationKeys.USERNAME_KEY]
-    authority = profile[ConfigurationKeys.AUTHORITY_KEY]
-    return username != _DEFAULT_VALUE and authority != _DEFAULT_VALUE and not profile_has_been_set()
+    _attach_config_file_to_profile(parser)
+    sections = list(parser.sections())
+    if ConfigurationKeys.INTERNAL_SECTION in sections:
+        sections.remove(ConfigurationKeys.INTERNAL_SECTION)
+    return sections
 
 
-def _get_config_profile_from_parser(parser):
-    config_file_path = _get_config_file_path()
+def _attach_config_file_to_profile(parser, profile_name=None):
+    config_file_path = _get_config_file_path(profile_name)
     parser.read(config_file_path)
-    config = parser[ConfigurationKeys.USER_SECTION]
-    return config
 
 
-def _get_config_file_path():
+def _get_config_file_path(profile_name=None):
     path = u"{}config.cfg".format(util.get_user_project_path())
-    if not os.path.exists(path) or not _verify_config_file(path):
-        _create_new_config_file(path)
+    if not os.path.exists(path):
+        _create_new_config_file(path, profile_name)
     return path
 
 
-def _create_new_config_file(path):
+def _create_new_config_file(path, profile_name):
+    profile_name = profile_name or DEFAULT_VALUE
     config_parser = ConfigParser()
-    config_parser = _create_user_section(config_parser)
     config_parser = _create_internal_section(config_parser)
-    _save(config_parser, None, path)
+    if profile_name != DEFAULT_VALUE:
+        config_parser = _create_profile_section(config_parser, profile_name)
+    _save(config_parser, profile_name, None, path)
 
 
-def _create_user_section(parser):
+def _create_internal_section(parser):
     keys = ConfigurationKeys
-    parser.add_section(keys.USER_SECTION)
-    parser[keys.USER_SECTION] = {}
-    parser[keys.USER_SECTION][keys.AUTHORITY_KEY] = _DEFAULT_VALUE
-    parser[keys.USER_SECTION][keys.USERNAME_KEY] = _DEFAULT_VALUE
-    parser[keys.USER_SECTION][keys.IGNORE_SSL_ERRORS_KEY] = u"False"
+    parser.add_section(keys.INTERNAL_SECTION)
+    parser[keys.INTERNAL_SECTION] = {}
+    parser[keys.INTERNAL_SECTION][keys.DEFAULT_PROFILE_IS_COMPLETE] = str(False)
+    parser[keys.INTERNAL_SECTION][keys.DEFAULT_PROFILE] = DEFAULT_VALUE
     return parser
 
 
-def _create_internal_section(parser):
+def _get_default_profile_name():
+    parser = ConfigParser()
+    _attach_config_file_to_profile(parser)
+    return parser[ConfigurationKeys.INTERNAL_SECTION][ConfigurationKeys.DEFAULT_PROFILE]
+
+
+def _print_profile_not_exists_message(profile_name):
+    util.print_error(u"Profile '{0}' does not exist.".format(profile_name))
+    util.print_set_profile_help()
+
+
+def _get_profile_from_parser(parser, profile_name):
+    _attach_config_file_to_profile(parser, profile_name)
+    if profile_name not in parser.sections():
+        _create_profile_section(parser, profile_name)
+
+    return parser[profile_name]
+
+
+def _create_profile_section(parser, profile_name):
     keys = ConfigurationKeys
-    parser.add_section(keys.INTERNAL_SECTION)
-    parser[keys.INTERNAL_SECTION] = {}
-    parser[keys.INTERNAL_SECTION][keys.HAS_SET_PROFILE_KEY] = u"False"
+    parser.add_section(profile_name)
+    parser[profile_name] = {}
+    parser[profile_name][keys.AUTHORITY_KEY] = DEFAULT_VALUE
+    parser[profile_name][keys.USERNAME_KEY] = DEFAULT_VALUE
+    parser[profile_name][keys.IGNORE_SSL_ERRORS_KEY] = str(False)
+
+    default_profile = parser[keys.INTERNAL_SECTION].get(keys.DEFAULT_PROFILE)
+    if default_profile is None or default_profile is DEFAULT_VALUE:
+        parser[keys.INTERNAL_SECTION][keys.DEFAULT_PROFILE] = profile_name
     return parser
 
 
-def _save(parser, key=None, path=None):
-    path = _get_config_file_path() if path is None else path
+def _try_mark_setup_as_complete(profile_name):
+    if not _setup_ready_for_completion(profile_name):
+        return
+
+    keys = ConfigurationKeys
+    parser = ConfigParser()
+    config_file_path = _get_config_file_path(profile_name)
+    parser.read(config_file_path)
+    settings = parser[keys.INTERNAL_SECTION]
+    settings[keys.DEFAULT_PROFILE_IS_COMPLETE] = str(True)
+
+    default_profile = parser[keys.INTERNAL_SECTION].get(keys.DEFAULT_PROFILE)
+    if default_profile is None or default_profile is DEFAULT_VALUE:
+        parser[keys.INTERNAL_SECTION][keys.DEFAULT_PROFILE] = profile_name
+
+    _save(parser, profile_name, keys.DEFAULT_PROFILE_IS_COMPLETE)
+
+
+def _setup_ready_for_completion(profile_name):
+    parser = ConfigParser()
+    profile = _get_profile_from_parser(parser, profile_name)
+    username = profile[ConfigurationKeys.USERNAME_KEY]
+    authority = profile[ConfigurationKeys.AUTHORITY_KEY]
+    username_exists = username is not None and username != DEFAULT_VALUE
+    authority_exists = authority is not None and authority != DEFAULT_VALUE
+    return username_exists and authority_exists and not _default_profile_exists()
+
+
+def _default_profile_exists():
+    parser = ConfigParser()
+    config_file_path = _get_config_file_path()
+    parser.read(config_file_path)
+    settings = parser[ConfigurationKeys.INTERNAL_SECTION]
+    return settings.getboolean(ConfigurationKeys.DEFAULT_PROFILE_IS_COMPLETE)
+
+
+def _save(parser, profile_name, key=None, path=None):
+    path = _get_config_file_path(profile_name) if path is None else path
     util.open_file(path, u"w+", lambda f: parser.write(f))
     if key is not None:
-        if key == ConfigurationKeys.HAS_SET_PROFILE_KEY:
+        if key == ConfigurationKeys.DEFAULT_PROFILE_IS_COMPLETE:
             print(u"You have completed setting up your profile!")
         else:
             print(u"'{}' has been successfully updated".format(key))
-
-
-def _verify_config_file(path):
-    keys = ConfigurationKeys
-    config_parser = ConfigParser()
-    config_parser.read(path)
-    sections = config_parser.sections()
-    return keys.USER_SECTION in sections and keys.INTERNAL_SECTION in sections

src/code42cli/profile/password.py

@@ -10,20 +10,20 @@
 _ROOT_SERVICE_NAME = u"code42cli"
 
 
-def get_password():
-    """Gets your currently stored password for your username / authority URL combo."""
-    profile = config.get_config_profile()
-    service_name = _get_service_name(profile)
+def get_password(profile_name):
+    """Gets your currently stored password for your profile."""
+    profile = config.get_profile(profile_name)
+    service_name = _get_service_name(profile_name)
     username = _get_username(profile)
     password = keyring.get_password(service_name, username)
     return password
 
 
-def set_password_from_prompt():
-    """Prompts and sets your password for your username / authority URL combo."""
+def set_password_from_prompt(profile_name):
+    """Prompts and sets your password for your profile."""
     password = getpass()
-    profile = config.get_config_profile()
-    service_name = _get_service_name(profile)
+    profile = config.get_profile(profile_name)
+    service_name = _get_service_name(profile_name)
     username = _get_username(profile)
     keyring.set_password(service_name, username, password)
     print(u"'Code42 Password' updated.")
@@ -34,9 +34,8 @@ def get_password_from_prompt():
     return getpass()
 
 
-def _get_service_name(profile):
-    authority_url = profile[ConfigurationKeys.AUTHORITY_KEY]
-    return u"{}::{}".format(_ROOT_SERVICE_NAME, authority_url)
+def _get_service_name(profile_name):
+    return u"{}::{}".format(_ROOT_SERVICE_NAME, profile_name)
 
 
 def _get_username(profile):