illumio-pylo 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

illumio_pylo/cli/commands/credential_manager.py

@@ -1,3 +1,5 @@
+import sys
+
 from prettytable import PrettyTable
 import argparse
 import os
@@ -7,7 +9,8 @@ import paramiko
 import illumio_pylo as pylo
 import click
 from illumio_pylo.API.CredentialsManager import get_all_credentials, create_credential_in_file, CredentialFileEntry, \
-    create_credential_in_default_file, encrypt_api_key_with_paramiko_key, decrypt_api_key_with_paramiko_key
+    create_credential_in_default_file, encrypt_api_key_with_paramiko_ssh_key_fernet, decrypt_api_key_with_paramiko_ssh_key_fernet, \
+    get_credentials_from_file
 
 from illumio_pylo import log
 from . import Command
@@ -20,19 +23,24 @@ objects_load_filter = None
 def fill_parser(parser: argparse.ArgumentParser):
     sub_parser = parser.add_subparsers(dest='sub_command', required=True)
     list_parser = sub_parser.add_parser('list', help='List all credentials')
-    create_parser = sub_parser.add_parser('create', help='Create a new credential')
 
-    create_parser.add_argument('--name', required=True, type=str,
-                               help='Name of the credential')
-    create_parser.add_argument('--fqdn', required=True, type=str,
+    test_parser = sub_parser.add_parser('test', help='Test a credential')
+    test_parser.add_argument('--name', required=False, type=str, default=None,
+                             help='Name of the credential profile to test')
+
+
+    create_parser = sub_parser.add_parser('create', help='Create a new credential')
+    create_parser.add_argument('--name', required=False, type=str, default=None,
+                     help='Name of the credential')
+    create_parser.add_argument('--fqdn', required=False, type=str, default=None,
                                  help='FQDN of the PCE')
-    create_parser.add_argument('--port', required=True, type=int,
+    create_parser.add_argument('--port', required=False, type=int, default=None,
                                  help='Port of the PCE')
-    create_parser.add_argument('--org', required=True, type=int,
+    create_parser.add_argument('--org', required=False, type=int, default=None,
                                  help='Organization ID')
-    create_parser.add_argument('--api-user', required=True, type=str,
+    create_parser.add_argument('--api-user', required=False, type=str, default=None,
                                     help='API user')
-    create_parser.add_argument('--verify-ssl', required=True, type=bool,
+    create_parser.add_argument('--verify-ssl', required=False, type=bool, default=None,
                                  help='Verify SSL')
 
 
@@ -54,14 +62,10 @@ def __main(args, **kwargs):
                   )
 
     elif args['sub_command'] == 'create':
-        print("Recap:")
-        print("Name: {}".format(args['name']))
-        print("FQDN: {}".format(args['fqdn']))
-        print("Port: {}".format(args['port']))
-        print("Org ID: {}".format(args['org']))
-        print("API User: {}".format(args['api_user']))
-        print("Verify SSL: {}".format(args['verify_ssl']))
-        print()
+
+        wanted_name = args['name']
+        if wanted_name is None:
+            wanted_name = click.prompt('> Input a Profile Name (ie: prod-pce)', type=str)
 
         print("* Checking if a credential with the same name already exists...", flush=True, end="")
         credentials = get_all_credentials()
@@ -70,20 +74,52 @@ def __main(args, **kwargs):
                 raise pylo.PyloEx("A credential named '{}' already exists".format(args['name']))
         print("OK!")
 
+        wanted_fqdn = args['fqdn']
+        if wanted_fqdn is None:
+            wanted_fqdn = click.prompt('> PCE FQDN (ie: pce1.mycompany.com)', type=str)
+
+        wanted_port = args['port']
+        if wanted_port is None:
+            wanted_port = click.prompt('> PCE Port (ie: 8443)', type=int)
+
+        wanted_org = args['org']
+        if wanted_org is None:
+            wanted_org = click.prompt('> Organization ID', type=int)
+
+        wanted_api_user = args['api_user']
+        if wanted_api_user is None:
+            wanted_api_user = click.prompt('> API User', type=str)
+
+        wanted_verify_ssl = args['verify_ssl']
+        if wanted_verify_ssl is None:
+            wanted_verify_ssl = click.prompt('> Verify SSL/TLS certificate? Y/N', type=bool)
+
+
+        print()
+        print("Recap:")
+        print("Name: {}".format(wanted_name))
+        print("FQDN: {}".format(wanted_fqdn))
+        print("Port: {}".format(wanted_port))
+        print("Org ID: {}".format(wanted_org))
+        print("API User: {}".format(wanted_api_user))
+        print("Verify SSL: {}".format(wanted_verify_ssl))
+        print()
+
+
         # prompt of API key from user input, single line, hidden
         api_key = click.prompt('> API Key', hide_input=True)
 
         credentials_data: CredentialFileEntry = {
-            "name": args['name'],
-            "fqdn": args['fqdn'],
-            "port": args['port'],
-            "org_id": args['org'],
-            "api_user": args['api_user'],
-            "verify_ssl": args['verify_ssl'],
+            "name": wanted_name,
+            "fqdn": wanted_fqdn,
+            "port": wanted_port,
+            "org_id": wanted_org,
+            "api_user": wanted_api_user,
+            "verify_ssl": wanted_verify_ssl,
             "api_key": api_key
         }
 
-        encrypt_api_key = click.prompt('> Encrypt API? Y/N', type=bool)
+        encrypt_api_key = click.prompt('> Encrypt API (requires an SSH agent running and an RSA or Ed25519 key) ? Y/N', type=bool)
         if encrypt_api_key:
             print("Available keys (ECDSA NISTPXXX keys and a few others are not supported and will be filtered out):")
             ssh_keys = paramiko.Agent().get_keys()
@@ -100,10 +136,10 @@ def __main(args, **kwargs):
                                                       selected_ssh_key.get_fingerprint().hex(),
                                                       selected_ssh_key.comment))
             print(" * encrypting API key with selected key (you may be prompted by your SSH agent for confirmation or PIN code) ...", flush=True, end="")
-            encrypted_api_key = encrypt_api_key_with_paramiko_key(ssh_key=selected_ssh_key, api_key=api_key)
+            encrypted_api_key = encrypt_api_key_with_paramiko_ssh_key_fernet(ssh_key=selected_ssh_key, api_key=api_key)
             print("OK!")
             print(" * trying to decrypt the encrypted API key...", flush=True, end="")
-            decrypted_api_key = decrypt_api_key_with_paramiko_key(encrypted_api_key_payload=encrypted_api_key)
+            decrypted_api_key = decrypt_api_key_with_paramiko_ssh_key_fernet(encrypted_api_key_payload=encrypted_api_key)
             if decrypted_api_key != api_key:
                 raise pylo.PyloEx("Decrypted API key does not match original API key")
             print("OK!")
@@ -122,6 +158,35 @@ def __main(args, **kwargs):
 
         print("OK! ({})".format(file_path))
 
+    elif args['sub_command'] == 'test':
+        print("* Profile Tester command")
+        wanted_name = args['name']
+        if wanted_name is None:
+            wanted_name = click.prompt('> Input a Profile Name to test (ie: prod-pce)', type=str)
+        found_profile = get_credentials_from_file(wanted_name, fail_with_an_exception=False)
+        if found_profile is None:
+            print("Cannot find a profile named '{}'".format(wanted_name))
+            print("Available profiles:")
+            credentials = get_all_credentials()
+            for credential in credentials:
+                print(" - {}".format(credential.name))
+            sys.exit(1)
+
+        print("Selected profile:")
+        print(" - Name: {}".format(found_profile.name))
+        print(" - FQDN: {}".format(found_profile.fqdn))
+        print(" - Port: {}".format(found_profile.port))
+        print(" - Org ID: {}".format(found_profile.org_id))
+        print(" - API User: {}".format(found_profile.api_user))
+        print(" - Verify SSL: {}".format(found_profile.verify_ssl))
+
+        print("* Testing credential...", flush=True, end="")
+        connector = pylo.APIConnector.create_from_credentials_object(found_profile)
+        connector.objects_label_dimension_get()
+        print("OK!")
+
+    else:
+        raise pylo.PyloEx("Unknown sub-command '{}'".format(args['sub_command']))
 
 command_object = Command(command_name, __main, fill_parser, credentials_manager_mode=True)
 

illumio_pylo/cli/commands/ruleset_export.py

@@ -1,6 +1,6 @@
 import argparse
 import os
-from typing import Dict, List
+from typing import Dict, List, Literal
 
 import illumio_pylo as pylo
 from illumio_pylo import ArraysToExcel, ExcelHeader
@@ -12,7 +12,7 @@ command_name = 'rule-export'
 
 def fill_parser(parser: argparse.ArgumentParser):
     parser.add_argument('--format', '-f', required=False, default='excel',choices=['csv', 'excel'], help='Output file format')
-    parser.add_argument('--output', '-o', required=False, default='.', help='Directory where to save the output file')
+    parser.add_argument('--output-dir', '-o', required=False, default='output', help='Directory where to save the output file')
     parser.add_argument('--prefix-objects-with-type', nargs='?', const=True, default=False,
                         help='Prefix objects with their type (e.g. "label:mylabel")')
     parser.add_argument('--object-types-as-section', action='store_true', default=False,
@@ -26,44 +26,26 @@ def fill_parser(parser: argparse.ArgumentParser):
 
 
 
-def __main(options: Dict, org: pylo.Organization, **kwargs):
-    csv_report_headers = pylo.ExcelHeaderSet(
-        [   ExcelHeader(name = 'ruleset', max_width = 40),
-            ExcelHeader(name = 'scope', max_width = 50),
-            ExcelHeader(name = 'type', max_width = 10),
-            ExcelHeader(name = 'consumers', max_width = 80),
-            ExcelHeader(name = 'providers', max_width = 80),
-            ExcelHeader(name = 'services', max_width = 30),
-            ExcelHeader(name = 'options', max_width = 40),
-            ExcelHeader(name = 'ruleset_url', max_width = 40, wrap_text = False),
-            ExcelHeader(name = 'ruleset_href', max_width = 30, wrap_text = False)
-            ])
-
-    setting_prefix_objects_with_type: bool|str = options['prefix_objects_with_type']
+def __main(args: Dict, org: pylo.Organization, **kwargs):
+
+    setting_prefix_objects_with_type: bool|str = args['prefix_objects_with_type']
+    setting_object_types_as_section: bool = args['prefix_objects_with_type']
+    settings_output_file_format = args['format']
+    settings_output_dir = args['output_dir']
+
+
     if setting_prefix_objects_with_type is False:
         print(" * Prefix for object types are disabled")
     else:
         print(" * Prefix for object types are enabled")
 
-    setting_object_types_as_section: bool = options['prefix_objects_with_type']
+
     if setting_object_types_as_section is False:
         print(" * Object types as section are disabled")
     else:
         print(" * Object types as section are enabled")
 
-    output_file_format = options.get('format')
-    if output_file_format == "excel":
-        output_file_extension = ".xlsx"
-    elif output_file_format == "csv":
-        output_file_extension = ".csv"
-    else:
-        raise Exception("Unknown output file format: %s" % output_file_format)
-
-    output_file_name = options.get('output') + os.sep + make_filename_with_timestamp('rule_export_') + output_file_extension
-    output_file_name = os.path.abspath(output_file_name)
-
-    csv_report = pylo.ArraysToExcel()
-    sheet = csv_report.create_sheet('rulesets', csv_report_headers, force_all_wrap_text=True, multivalues_cell_delimiter=',')
+    csv_report, output_file_name, sheet = prepare_csv_report_object(settings_output_file_format, settings_output_dir)
 
     for ruleset in org.RulesetStore.rulesets:
         for rule in ruleset.rules_ordered_by_type:
@@ -103,23 +85,47 @@ def __main(options: Dict, org: pylo.Organization, **kwargs):
                     'services': rule.services.members_to_str("\n"),
                     'options': pylo.string_list_to_text(rule_options, "\n"),
                     'ruleset_href': ruleset.href,
-                    'ruleset_url': ruleset.get_ruleset_url()}
-            if rule.is_extra_scope():
-                data['type'] = 'extra'
-            else:
-                data['type'] = 'intra'
+                    'ruleset_url': ruleset.get_ruleset_url(),
+                    'type': 'intra' if rule.is_intra_scope() else 'extra'
+                    }
+
             sheet.add_line_from_object(data)
 
-    if output_file_format == "csv":
+    if settings_output_file_format == "csv":
         print(" * Writing export file '{}' ... ".format(output_file_name), end='', flush=True)
         sheet.write_to_csv(output_file_name)
         print("DONE")
-    elif output_file_format == "excel":
+    elif settings_output_file_format == "excel":
         print(" * Writing export file '{}' ... ".format(output_file_name), end='', flush=True)
         csv_report.write_to_excel(output_file_name)
         print("DONE")
     else:
-        raise pylo.PyloEx("Unknown format: '{}'".format(options['format']))
+        raise pylo.PyloEx("Unknown format: '{}'".format(args['format']))
+
+
+def prepare_csv_report_object(output_file_format: Literal['excel', 'csv'], settings_output_dir: str):
+    if output_file_format == "excel":
+        output_file_extension = ".xlsx"
+    elif output_file_format == "csv":
+        output_file_extension = ".csv"
+    else:
+        raise Exception("Unknown output file format: %s" % output_file_format)
+    csv_report_headers = pylo.ExcelHeaderSet(
+        [ExcelHeader(name='ruleset', max_width=40),
+         ExcelHeader(name='scope', max_width=50),
+         ExcelHeader(name='type', max_width=10),
+         ExcelHeader(name='consumers', max_width=80),
+         ExcelHeader(name='providers', max_width=80),
+         ExcelHeader(name='services', max_width=30),
+         ExcelHeader(name='options', max_width=40),
+         ExcelHeader(name='ruleset_url', max_width=40, wrap_text=False),
+         ExcelHeader(name='ruleset_href', max_width=30, wrap_text=False)
+         ])
+    csv_report = ArraysToExcel()
+    sheet = csv_report.create_sheet('rulesets', csv_report_headers, force_all_wrap_text=True,
+                                    multivalues_cell_delimiter=',')
+    output_file_name = make_filename_with_timestamp('rule_export_', settings_output_dir) + output_file_extension
+    return csv_report, output_file_name, sheet
 
 
 command_object = Command(command_name, __main, fill_parser)

illumio_pylo/cli/commands/utils/misc.py

@@ -8,5 +8,9 @@ def make_filename_with_timestamp(prefix: str, output_directory: str = './') -> s
     if output_directory.startswith('.') or not output_directory.startswith('/') or not output_directory.startswith('\\'):
         output_directory = os.path.realpath(os.getcwd() + os.path.sep + output_directory)
 
+    # if the directory does not exist, we will create it and its parents if needed
+    if not os.path.exists(output_directory):
+        os.makedirs(output_directory)
+
     now = datetime.now()
     return output_directory + os.path.sep + prefix + now.strftime("%Y%m%d-%H%M%S")

illumio_pylo/cli/commands/ven_upgrader.py

@@ -11,14 +11,8 @@ objects_load_filter = ['workloads', 'labels']
 
 
 def fill_parser(parser: argparse.ArgumentParser):
-    parser.add_argument('--filter-env-label', type=str, required=False, default=None,
-                        help='Filter agents by environment labels (separated by commas)')
-    parser.add_argument('--filter-loc-label', type=str, required=False, default=None,
-                        help='Filter agents by location labels (separated by commas)')
-    parser.add_argument('--filter-app-label', type=str, required=False, default=None,
-                        help='Filter agents by application labels (separated by commas)')
-    parser.add_argument('--filter-role-label', type=str, required=False, default=None,
-                        help='Filter agents by role labels (separated by commas)')
+    parser.add_argument('--filter-label', '-fl', action='append',
+                        help='Only look at workloads matching specified labels')
 
     parser.add_argument('--filter-ven-versions', nargs='+', type=str, required=False, default=None,
                         help='Filter agents by versions (separated by spaces)')
@@ -67,58 +61,13 @@ def __main(args, org: pylo.Organization, **kwargs):
     target_version = pylo.SoftwareVersion(target_version_string)
 
     print(" * Parsing filters")
-
-    env_label_list = {}
-    if args['filter_env_label'] is not None:
-        print("   * Environment Labels specified")
-        for raw_label_name in args['filter_env_label'].split(','):
-            print("     - label named '{}'".format(raw_label_name), end='', flush=True)
-            label = org.LabelStore.find_label_by_name_and_type(raw_label_name, pylo.label_type_env)
-            if label is None:
-                print("NOT FOUND!")
-                raise pylo.PyloEx("Cannot find label named '{}'".format(raw_label_name))
-            else:
-                print("found")
-                env_label_list[label] = label
-
-    loc_label_list = {}
-    if args['filter_loc_label'] is not None:
-        print("   * Location Labels specified")
-        for raw_label_name in args['filter_loc_label'].split(','):
-            print("     - label named '{}' ".format(raw_label_name), end='', flush=True)
-            label = org.LabelStore.find_label_by_name_and_type(raw_label_name, pylo.label_type_loc)
-            if label is None:
-                print("NOT FOUND!")
-                raise pylo.PyloEx("Cannot find label named '{}'".format(raw_label_name))
-            else:
-                print("found")
-                loc_label_list[label] = label
-
-    app_label_list = {}
-    if args['filter_app_label'] is not None:
-        print("   * Application Labels specified")
-        for raw_label_name in args['filter_app_label'].split(','):
-            print("     - label named '{}' ".format(raw_label_name), end='', flush=True)
-            label = org.LabelStore.find_label_by_name_and_type(raw_label_name, pylo.label_type_app)
-            if label is None:
-                print("NOT FOUND!")
-                raise pylo.PyloEx("Cannot find label named '{}'".format(raw_label_name))
-            else:
-                print("found")
-                app_label_list[label] = label
-
-    role_label_list = {}
-    if args['filter_role_label'] is not None:
-        print("   * Role Labels specified")
-        for raw_label_name in args['filter_role_label']:
-            print("     - label named '{}' ".format(raw_label_name), end='', flush=True)
-            label = org.LabelStore.find_label_by_name_and_type(raw_label_name, pylo.label_type_role)
+    filter_labels: List[pylo.Label] = []  # the list of labels to filter the workloads against
+    if args['filter_label'] is not None:
+        for label_name in args['filter_label']:
+            label = org.LabelStore.find_label_by_name(label_name)
             if label is None:
-                print("NOT FOUND!")
-                raise pylo.PyloEx("Cannot find label named '{}'".format(raw_label_name))
-            else:
-                print("found")
-                role_label_list[label] = label
+                raise pylo.PyloEx("Cannot find label '{}' in the PCE".format(label_name))
+            filter_labels.append(label)
 
     filter_versions = {}
     if args['filter_ven_versions'] is not None:
@@ -149,25 +98,8 @@ def __main(args, org: pylo.Organization, **kwargs):
                 del agents[agent_href]
                 continue
 
-        if len(env_label_list) > 0 and (workload.env_label is None or workload.env_label not in env_label_list):
-            pylo.log.debug(" - workload '{}' does not match env_label filters, it's out!".format(workload.get_name()))
-            del agents[agent_href]
-            continue
-        if len(loc_label_list) > 0 and (workload.loc_label is None or workload.loc_label not in loc_label_list):
-            pylo.log.debug(" - workload '{}' does not match loc_label filters, it's out!".format(workload.get_name()))
-            del agents[agent_href]
-            continue
-        if len(app_label_list) > 0 and (workload.app_label is None or workload.app_label not in app_label_list):
-            pylo.log.debug(" - workload '{}' does not match app_label filters, it's out!".format(workload.get_name()))
-            del agents[agent_href]
-            continue
-        if len(role_label_list) > 0 and (workload.role_label is None or workload.role_label not in role_label_list):
-            pylo.log.debug(" - workload '{}' does not match role_label filters, it's out!".format(workload.get_name()))
-            del agents[agent_href]
-            continue
-
-        if agent.software_version.version_string not in filter_versions:
-            pylo.log.debug(" - workload '{}' does not match the version filter, it's out!".format(workload.get_name()))
+        if workload.uses_all_labels(filter_labels) is False:
+            pylo.log.debug(" - workload '{}' is not matching the labels filter".format(workload.get_name()))
             del agents[agent_href]
             continue
 

illumio_pylo/cli/commands/workload_export.py

@@ -80,9 +80,11 @@ def __main(args, org: pylo.Organization, **kwargs):
     for label_type in org.LabelStore.label_types:
         csv_report_headers.append(f'label_{label_type}')
 
-    csv_report_headers.extend(['online', 'managed', 'status', 'agent.last_heartbeat',
-                               'agent.sec_policy_sync_state', 'agent.sec_policy_applied_at',
-                          'href', 'agent.href'])
+    csv_report_headers.extend([
+        'online', 'managed', 'status', 'agent.last_heartbeat',
+        'agent.sec_policy_sync_state', 'agent.sec_policy_applied_at',
+        ExcelHeader(name='link_to_pce', wrap_text=False, url_text='See in PCE', is_url=True),
+        'href', 'agent.href'])
 
     for extra_column in extra_columns:
         csv_report_headers.append(extra_column.column_description().name)
@@ -110,7 +112,7 @@ def __main(args, org: pylo.Organization, **kwargs):
         for field in filter_data._detected_headers:
             csv_report_headers.append('_' + field)
 
-    csv_report = pylo.ArraysToExcel()
+    csv_report = ArraysToExcel()
     csv_sheet = csv_report.create_sheet('workloads', csv_report_headers, force_all_wrap_text=True)
 
     all_workloads = org.WorkloadStore.itemsByHRef.copy()
@@ -132,6 +134,7 @@ def __main(args, org: pylo.Organization, **kwargs):
                 'online': wkl.online,
                 'managed': not wkl.unmanaged,
                 'status': wkl.get_status_string(),
+                'link_to_pce': wkl.href,
             }
             for label_type in org.LabelStore.label_types:
                 new_row[f'label_{label_type}'] = wkl.get_label_name(label_type)

illumio_pylo/cli/commands/workload_import.py

@@ -3,6 +3,8 @@ from dataclasses import dataclass
 import sys
 import argparse
 
+import click
+
 import illumio_pylo as pylo
 from illumio_pylo import ArraysToExcel, ExcelHeaderSet, ExcelHeader
 from .utils.LabelCreation import generate_list_of_labels_to_create, create_labels
@@ -43,6 +45,12 @@ def fill_parser(parser: argparse.ArgumentParser):
     parser.add_argument('--batch-size', type=int, required=False, default=500,
                         help='Number of Workloads to create per API call')
 
+    parser.add_argument('--proceed-with-creation', '-p', action='store_true',
+                        help='If set, the script will proceed with the creation of the workloads')
+
+    parser.add_argument('--no-confirmation-required', '-n', action='store_true',
+                        help='If set, the script will proceed with the creation of the workloads and labels without asking for confirmation')
+
 
 
 def __main(args, org: pylo.Organization, **kwargs):
@@ -54,6 +62,8 @@ def __main(args, org: pylo.Organization, **kwargs):
     settings_header_label_prefix: str = args['label_type_header_prefix']
     settings_ignore_all_sorts_collisions: bool = args['ignore_all_sorts_collisions']
     settings_ignore_empty_ip_entries: bool = args['ignore_empty_ip_entries']
+    settings_proceed_with_creation: bool = args['proceed_with_creation']
+    settings_no_confirmation_required: bool = args['no_confirmation_required']
     settings_output_dir: str = args['output_dir']
 
     batch_size = args['batch_size']
@@ -113,6 +123,11 @@ def __main(args, org: pylo.Organization, **kwargs):
     # <editor-fold desc="Missing Labels creation">
     if len(labels_to_be_created) > 0:
         print(" * {} Labels need to created before Workloads can be imported, listing:".format(len(labels_to_be_created)))
+        for label in labels_to_be_created:
+            print("   - Label: {} (type={})".format(label.name, label.type))
+        if not settings_no_confirmation_required:
+            click.confirm("Do you want to proceed with the creation of these labels?", abort=True)
+
         create_labels(labels_to_be_created, org)
     # </editor-fold>
 
@@ -134,21 +149,37 @@ def __main(args, org: pylo.Organization, **kwargs):
         print(" * No Workloads to create, all were ignored due to collisions or missing data.")
         # still want to save the CSV/Excel files in the end so don't exit
     else:
-        print(" * Creating {} Unmanaged Workloads in batches of {}".format(umw_creator_manager.count_drafts(), batch_size))
-        total_created_count = 0
-        total_failed_count = 0
-
-        results = umw_creator_manager.create_all_in_pce(amount_created_per_batch=batch_size, retrieve_workloads_after_creation=False)
-        for result in results:
-            if result.success:
-                total_created_count += 1
-                result.external_tracker_id['href'] = result.workload_href
+        if not settings_proceed_with_creation is True:
+            print(" * No workload will be created because the --proceed-with-creation/-p flag was not set. Yet report will be generated")
+            for object_to_create in csv_objects_to_create:
+                if '**not_created_reason**' not in object_to_create:
+                    object_to_create['**not_created_reason**'] = '--proceed-with-creation/-p flag was not set'
+        else:
+            confirmed = settings_no_confirmation_required
+            print(" * Creating {} Unmanaged Workloads in batches of {}".format(umw_creator_manager.count_drafts(), batch_size))
+            if not settings_no_confirmation_required:
+                confirmed = click.confirm("Do you want to proceed with the creation of these workloads?")
+
+            if not confirmed:
+                print(" * No Workloads will be created, user aborted the operation")
+                for object_to_create in csv_objects_to_create:
+                    if '**not_created_reason**' not in object_to_create:
+                        object_to_create['**not_created_reason**'] = 'user aborted the operation'
             else:
-                total_failed_count += 1
-                result.external_tracker_id['**not_created_reason**'] = result.message
+                total_created_count = 0
+                total_failed_count = 0
+
+                results = umw_creator_manager.create_all_in_pce(amount_created_per_batch=batch_size, retrieve_workloads_after_creation=False)
+                for result in results:
+                    if result.success:
+                        total_created_count += 1
+                        result.external_tracker_id['href'] = result.workload_href
+                    else:
+                        total_failed_count += 1
+                        result.external_tracker_id['**not_created_reason**'] = result.message
 
-        print("  * DONE - {} created with success, {} failures and {} ignored.".format(
-            total_created_count, total_failed_count, ignored_objects_count))
+                print("  * DONE - {} created with success, {} failures and {} ignored.".format(
+                    total_created_count, total_failed_count, ignored_objects_count))
     # </editor-fold>
 
     print()

illumio_pylo/tmp.py

@@ -3,12 +3,11 @@ from datetime import datetime
 
 import illumio_pylo as pylo
 
-log = logging.getLogger('Pylo')
-
+log = logging.getLogger('PYLO')
 
 def init_logger():
     console_logger = logging.StreamHandler()
-    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    formatter = logging.Formatter('%(asctime)s %(levelname)s %(name)s/%(filename)s:%(lineno)d - %(message)s')
     console_logger.setFormatter(formatter)
     log.addHandler(console_logger)
 
@@ -32,7 +31,12 @@ def get_logger():
     return log
 
 
-def find_connector_or_die(obj):
+def find_connector_or_die(obj) -> 'pylo.APIConnector':
+    """
+    Find the APIConnector object in the object or its owner recursively. Will raise an exception if not found
+    :param obj:
+    :return:
+    """
     connector = obj.__dict__.get('connector')  # type: pylo.APIConnector
     if connector is None:
         owner = obj.__dict__.get('owner')

{illumio_pylo-0.3.1.dist-info → illumio_pylo-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: illumio_pylo
-Version: 0.3.1
+Version: 0.3.3
 Summary: A set of tools and library for working with Illumio PCE
 Home-page: https://github.com/cpainchaud/pylo
 Author: Christophe Painchaud