illumio-pylo 0.3.11__py3-none-any.whl → 0.3.12__py3-none-any.whl

illumio_pylo/cli/commands/ui/credential_manager_ui/styles.css

@@ -0,0 +1,430 @@
+/* Base styles */
+* {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+    background-color: #f5f7fa;
+    color: #333;
+    line-height: 1.6;
+}
+
+.container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 20px;
+}
+
+/* Header */
+header {
+    text-align: center;
+    margin-bottom: 30px;
+    padding: 20px;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    border-radius: 10px;
+    color: white;
+}
+
+header h1 {
+    font-size: 2rem;
+    margin-bottom: 5px;
+}
+
+header .subtitle {
+    opacity: 0.9;
+    font-size: 1rem;
+}
+
+/* Buttons */
+.btn {
+    padding: 10px 20px;
+    border: none;
+    border-radius: 5px;
+    cursor: pointer;
+    font-size: 0.95rem;
+    font-weight: 500;
+    transition: all 0.2s ease;
+}
+
+.btn-primary {
+    background-color: #667eea;
+    color: white;
+}
+
+.btn-primary:hover {
+    background-color: #5a6fd6;
+}
+
+.btn-secondary {
+    background-color: #e2e8f0;
+    color: #4a5568;
+}
+
+.btn-secondary:hover {
+    background-color: #cbd5e0;
+}
+
+.btn-danger {
+    background-color: #e53e3e;
+    color: white;
+}
+
+.btn-danger:hover {
+    background-color: #c53030;
+}
+
+.btn-success {
+    background-color: #38a169;
+    color: white;
+}
+
+.btn-success:hover {
+    background-color: #2f855a;
+}
+
+.btn-small {
+    padding: 5px 10px;
+    font-size: 0.85rem;
+}
+
+/* Section styles */
+section {
+    background: white;
+    border-radius: 10px;
+    padding: 25px;
+    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.08);
+}
+
+.section-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 20px;
+}
+
+.section-header h2 {
+    font-size: 1.3rem;
+    color: #2d3748;
+}
+
+/* Table styles */
+table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+th, td {
+    padding: 12px 15px;
+    text-align: left;
+    border-bottom: 1px solid #e2e8f0;
+}
+
+th {
+    background-color: #f7fafc;
+    font-weight: 600;
+    color: #4a5568;
+    font-size: 0.85rem;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+tr:hover {
+    background-color: #f7fafc;
+}
+
+td {
+    font-size: 0.95rem;
+}
+
+.actions-cell {
+    white-space: nowrap;
+}
+
+.actions-cell .btn {
+    margin-right: 5px;
+}
+
+.actions-cell .btn:last-child {
+    margin-right: 0;
+}
+
+/* Status indicators */
+.status-yes {
+    color: #38a169;
+    font-weight: 500;
+}
+
+.status-no {
+    color: #e53e3e;
+    font-weight: 500;
+}
+
+/* Loading and empty states */
+.loading, .empty-state {
+    text-align: center;
+    padding: 40px;
+    color: #718096;
+}
+
+.loading::before {
+    content: '⏳ ';
+}
+
+.empty-state {
+    background-color: #f7fafc;
+    border-radius: 8px;
+}
+
+/* Notifications */
+.notification {
+    padding: 15px 20px;
+    border-radius: 8px;
+    margin-bottom: 20px;
+    font-weight: 500;
+}
+
+.notification.success {
+    background-color: #c6f6d5;
+    color: #276749;
+    border: 1px solid #9ae6b4;
+}
+
+.notification.error {
+    background-color: #fed7d7;
+    color: #c53030;
+    border: 1px solid #feb2b2;
+}
+
+.notification.info {
+    background-color: #bee3f8;
+    color: #2b6cb0;
+    border: 1px solid #90cdf4;
+}
+
+/* Modal */
+.modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0, 0, 0, 0.5);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    z-index: 1000;
+}
+
+.modal-content {
+    background: white;
+    border-radius: 12px;
+    width: 90%;
+    max-width: 550px;
+    max-height: 90vh;
+    overflow-y: auto;
+    box-shadow: 0 10px 40px rgba(0, 0, 0, 0.2);
+}
+
+.modal-small {
+    max-width: 400px;
+}
+
+.modal-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 20px 25px;
+    border-bottom: 1px solid #e2e8f0;
+}
+
+.modal-header h2 {
+    font-size: 1.2rem;
+    color: #2d3748;
+}
+
+.btn-close {
+    background: none;
+    border: none;
+    font-size: 1.5rem;
+    color: #a0aec0;
+    cursor: pointer;
+    line-height: 1;
+}
+
+.btn-close:hover {
+    color: #4a5568;
+}
+
+/* Form styles */
+form {
+    padding: 25px;
+}
+
+.form-group {
+    margin-bottom: 20px;
+}
+
+.form-group label {
+    display: block;
+    margin-bottom: 6px;
+    font-weight: 500;
+    color: #4a5568;
+    font-size: 0.95rem;
+}
+
+.form-group input[type="text"],
+.form-group input[type="number"],
+.form-group input[type="password"],
+.form-group select {
+    width: 100%;
+    padding: 10px 12px;
+    border: 1px solid #e2e8f0;
+    border-radius: 6px;
+    font-size: 1rem;
+    transition: border-color 0.2s;
+}
+
+.form-group input:focus,
+.form-group select:focus {
+    outline: none;
+    border-color: #667eea;
+    box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
+}
+
+.form-group small {
+    display: block;
+    margin-top: 5px;
+    color: #718096;
+    font-size: 0.85rem;
+}
+
+.form-row {
+    display: flex;
+    gap: 15px;
+}
+
+.form-row .form-group {
+    flex: 1;
+}
+
+.checkbox-group label {
+    display: flex;
+    align-items: center;
+    cursor: pointer;
+}
+
+.checkbox-group input[type="checkbox"] {
+    margin-right: 10px;
+    width: 18px;
+    height: 18px;
+}
+
+.form-section {
+    background-color: #f7fafc;
+    padding: 15px;
+    border-radius: 8px;
+    margin-bottom: 20px;
+}
+
+.form-section h3 {
+    font-size: 1rem;
+    color: #4a5568;
+    margin-bottom: 15px;
+}
+
+.form-actions {
+    display: flex;
+    justify-content: flex-end;
+    gap: 10px;
+    padding-top: 15px;
+    border-top: 1px solid #e2e8f0;
+}
+
+/* Test result */
+.test-result {
+    padding: 25px;
+    text-align: center;
+}
+
+.test-result.success {
+    color: #276749;
+}
+
+.test-result.success::before {
+    content: '✅ ';
+    font-size: 2rem;
+    display: block;
+    margin-bottom: 10px;
+}
+
+.test-result.error {
+    color: #c53030;
+}
+
+.test-result.error::before {
+    content: '❌ ';
+    font-size: 2rem;
+    display: block;
+    margin-bottom: 10px;
+}
+
+.test-result.loading::before {
+    content: '🔄 ';
+    font-size: 2rem;
+    display: block;
+    margin-bottom: 10px;
+    animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+    from { transform: rotate(0deg); }
+    to { transform: rotate(360deg); }
+}
+
+/* Utility classes */
+.hidden {
+    display: none !important;
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+    .form-row {
+        flex-direction: column;
+        gap: 0;
+    }
+
+    table {
+        font-size: 0.85rem;
+    }
+
+    th, td {
+        padding: 8px 10px;
+    }
+
+    .section-header {
+        flex-direction: column;
+        gap: 15px;
+        align-items: flex-start;
+    }
+}
+
+/* Delete confirmation modal */
+.delete-confirmation {
+    padding: 25px;
+    text-align: center;
+}
+
+.delete-confirmation p {
+    margin-bottom: 10px;
+    font-size: 1rem;
+}
+
+.delete-confirmation .warning-text {
+    color: #c53030;
+    font-size: 0.9rem;
+    font-style: italic;
+}
+

illumio_pylo/cli/commands/ven_duplicate_remover.py

@@ -2,15 +2,16 @@ from typing import Dict, List, Literal, Optional
 import datetime
 import click
 import argparse
+import os
 
 import illumio_pylo as pylo
-from illumio_pylo import ExcelHeader, nice_json
+from illumio_pylo import ExcelHeader
 
 from .utils.misc import make_filename_with_timestamp
 from . import Command
 
 command_name = 'ven-duplicate-remover'
-objects_load_filter = ['labels']
+objects_load_filter = ['labels', 'workloads']
 
 
 def fill_parser(parser: argparse.ArgumentParser):
@@ -37,8 +38,18 @@ def fill_parser(parser: argparse.ArgumentParser):
     parser.add_argument('--limit-number-of-deleted-workloads', '-l', type=int, default=None,
                         help='Limit the number of workloads to be deleted, for a limited test run for example.')
 
+    # New option: don't delete if labels mismatch across duplicates
+    parser.add_argument('--do-not-delete-if-labels-mismatch', action='store_true',
+                        help='Do not delete workloads for a duplicated hostname if the workloads do not all have the same set of labels')
+
+    # New option: ignore PCE online status and allow online workloads to be considered for deletion
+    parser.add_argument('--ignore-pce-online-status', action='store_true',
+                        help='Bypass the logic that keeps online workloads; when set online workloads will be treated like offline ones for deletion decisions')
+
     parser.add_argument('--output-dir', '-o', type=str, required=False, default="output",
                         help='Directory where to write the report file(s)')
+    parser.add_argument('--output-filename', type=str, default=None,
+                        help='Write report to the specified file (or basename) instead of using the default timestamped filename. If multiple formats are requested, the provided path\'s extension will be replaced/added per format.')
 
 
 def __main(args, org: pylo.Organization, pce_cache_was_used: bool, **kwargs):
@@ -55,11 +66,16 @@ def __main(args, org: pylo.Organization, pce_cache_was_used: bool, **kwargs):
     arg_do_not_delete_if_last_heartbeat_is_more_recent_than = args['do_not_delete_if_last_heartbeat_is_more_recent_than']
     arg_override_pce_offline_timer_to = args['override_pce_offline_timer_to']
     arg_limit_number_of_deleted_workloads = args['limit_number_of_deleted_workloads']
-    arg_report_output_dir: str = args['output_dir']
-
-    output_file_prefix = make_filename_with_timestamp('ven-duplicate-removal_', arg_report_output_dir)
-    output_file_csv = output_file_prefix + '.csv'
-    output_file_excel = output_file_prefix + '.xlsx'
+    arg_ignore_pce_online_status = args['ignore_pce_online_status'] is True
+    arg_do_not_delete_if_labels_mismatch = args['do_not_delete_if_labels_mismatch'] is True
+    arg_report_output_dir: str = args['output_dir'] 
+
+    # Determine output filename behavior: user provided filename/basename or use timestamped prefix
+    arg_output_filename: Optional[str] = args.get('output_filename')
+    if arg_output_filename is None:
+        output_file_prefix = make_filename_with_timestamp('ven-duplicate-removal_', arg_report_output_dir)
+    else:
+        output_file_prefix = None
 
     csv_report_headers = pylo.ExcelHeaderSet([
         ExcelHeader(name='name', max_width=40),
@@ -88,47 +104,11 @@ def __main(args, org: pylo.Organization, pce_cache_was_used: bool, **kwargs):
                 raise pylo.PyloEx("Cannot find label '{}' in the PCE".format(label_name))
             filter_labels.append(label)
 
-    # <editor-fold desc="Download workloads from PCE">
-    if not pce_cache_was_used:
-        print("* Downloading Workloads data from the PCE (it may take moment for large amounts of workloads) ... ", flush=True, end='')
-        if args['filter_label'] is None:
-            workloads_json = org.connector.objects_workload_get(async_mode=True, max_results=1000000)
-        else:
-            filter_labels_list_of_list: List[List[pylo.Label]] = []
-            # convert filter_labels dict to an array of arrays
-            for label_type, label_list in org.LabelStore.Utils.list_to_dict_by_type(filter_labels).items():
-                filter_labels_list_of_list.append(label_list)
-
-            # convert filter_labels_list_of_list to a matrix of all possibilities
-            # example: [[a,b],[c,d]] becomes [[a,c],[a,d],[b,c],[b,d]]
-            filter_labels_matrix = [[]]
-            for label_list in filter_labels_list_of_list:
-                new_matrix = []
-                for label in label_list:
-                    for row in filter_labels_matrix:
-                        new_row = row.copy()
-                        new_row.append(label.href)
-                        new_matrix.append(new_row)
-                filter_labels_matrix = new_matrix
-
-            workloads_json = org.connector.objects_workload_get(async_mode=False, max_results=1000000, filter_by_label=filter_labels_matrix)
-
-        org.WorkloadStore.load_workloads_from_json(workloads_json)
-
-    print("OK! {} workloads loaded".format(org.WorkloadStore.count_workloads()))
-    # </editor-fold>
-
-    all_workloads: List[pylo.Workload]  # the list of all workloads to be processed
-
-    if pce_cache_was_used:
-        # if some filters were used, let's apply them now
-        print("* Filtering workloads loaded from cache based on their labels... ", end='', flush=True)
-        # if some label filters were used, we will apply them at later stage
-        all_workloads: List[pylo.Workload] = list((org.WorkloadStore.find_workloads_matching_all_labels(filter_labels)).values())
-        print("OK! {} workloads left after filtering".format(len(all_workloads)))
-    else:
-        # filter was already applied during the download from the PCE
-        all_workloads = org.WorkloadStore.workloads
+    # if some filters were used, let's apply them now
+    print("* Filtering workloads loaded based on their labels... ", end='', flush=True)
+    # if some label filters were used, we will apply them at later stage
+    all_workloads: List[pylo.Workload] = list((org.WorkloadStore.find_workloads_matching_all_labels(filter_labels)).values())
+    print("OK! {} workloads left after filtering".format(len(all_workloads)))
 
     def add_workload_to_report(workload: pylo.Workload, action: str):
         url_link_to_pce = workload.get_pce_ui_url()
@@ -147,9 +127,8 @@ def __main(args, org: pylo.Organization, pce_cache_was_used: bool, **kwargs):
 
         sheet.add_line_from_object(new_row)
 
-    duplicated_hostnames = DuplicateRecordManager(arg_override_pce_offline_timer_to)
-
     print(" * Looking for VEN with duplicated hostname(s)")
+    duplicated_hostnames = DuplicateRecordManager(arg_override_pce_offline_timer_to)
 
     for workload in all_workloads:
         if workload.deleted:
@@ -161,10 +140,12 @@ def __main(args, org: pylo.Organization, pce_cache_was_used: bool, **kwargs):
 
     print(" * Found {} duplicated hostnames".format(duplicated_hostnames.count_duplicates()))
 
-    delete_tracker = org.connector.new_tracker_workload_multi_delete()
+    delete_tracker = org.connector.new_tracker_workload_multi_delete()  # tracker to handle deletions, it will be executed later
 
+    # Process each duplicated hostname record
     for dup_hostname, dup_record in duplicated_hostnames._records.items():
-        if not dup_record.has_duplicates():
+
+        if not dup_record.has_duplicates():  # no duplicates, skip
             continue
 
         print("  - hostname '{}' has duplicates. ({} online, {} offline, {} unmanaged)".format(dup_hostname,
@@ -172,13 +153,27 @@ def __main(args, org: pylo.Organization, pce_cache_was_used: bool, **kwargs):
                                                                                                len(dup_record.offline),
                                                                                                len(dup_record.unmanaged)))
 
+        # If the new flag was passed, ensure all workloads under this duplicate record have identical labels
+        if arg_do_not_delete_if_labels_mismatch:
+            label_strings = set()
+            for wkl in dup_record.all:
+                # Use workload.get_labels_str() to produce a stable representation across label types
+                lbl_str = wkl.get_labels_str()
+                label_strings.add(lbl_str)
+
+            if len(label_strings) > 1:
+                print("    - IGNORED: workloads for hostname '{}' have mismatching labels".format(dup_hostname))
+                for wkl in dup_record.all:
+                    add_workload_to_report(wkl, "ignored (labels mismatch)")
+                continue
+
         if not dup_record.has_no_managed_workloads():
             latest_created_workload = dup_record.find_latest_managed_created_at()
             latest_heartbeat_workload = dup_record.find_latest_heartbeat()
 
             print("    - Latest created at {} and latest heartbeat at {}".format(latest_created_workload.created_at, latest_heartbeat_workload.ven_agent.get_last_heartbeat_date()))
 
-            if dup_record.count_online() == 0:
+            if not arg_ignore_pce_online_status and dup_record.count_online() == 0:
                 print("     - IGNORED: there is no VEN online")
                 for wkl in dup_record.offline:
                     add_workload_to_report(wkl, "ignored (no VEN online)")
@@ -188,10 +183,18 @@ def __main(args, org: pylo.Organization, pce_cache_was_used: bool, **kwargs):
                 print("     - WARNING: there are more than 1 VEN online")
 
             # Don't delete online workloads but still show them in the report
-            for wkl in dup_record.online:
-                add_workload_to_report(wkl, "ignored (VEN is online)")
+            if not arg_ignore_pce_online_status:
+                for wkl in dup_record.online:
+                    add_workload_to_report(wkl, "ignored (VEN is online)")
+
+            # Build the list of candidate workloads to consider for deletion. If --ignore-pce-online-status
+            # is passed, include online workloads among the candidates.
+            if arg_ignore_pce_online_status:
+                deletion_candidates = list(dup_record.offline) + list(dup_record.online)
+            else:
+                deletion_candidates = list(dup_record.offline)
 
-            for wkl in dup_record.offline:
+            for wkl in deletion_candidates:
                 if arg_do_not_delete_the_most_recent_workload and wkl is latest_created_workload:
                     print("    - IGNORED: wkl {}/{} is the most recent".format(wkl.get_name_stripped_fqdn(), wkl.href))
                     add_workload_to_report(wkl, "ignored (it is the most recently created)")
@@ -207,7 +210,7 @@ def __main(args, org: pylo.Organization, pce_cache_was_used: bool, **kwargs):
                         add_workload_to_report(wkl, "ignored (limit of {} workloads to be deleted was reached)".format(arg_limit_number_of_deleted_workloads))
                     else:
                         delete_tracker.add_workload(wkl)
-                        print("    - added offline wkl {}/{} to the delete list".format(wkl.get_name_stripped_fqdn(), wkl.href))
+                        print("    - added wkl {}/{} to the delete list".format(wkl.get_name_stripped_fqdn(), wkl.href))
 
             for wkl in dup_record.unmanaged:
                 if arg_limit_number_of_deleted_workloads is not None and delete_tracker.count_entries() >= arg_limit_number_of_deleted_workloads:
@@ -257,7 +260,8 @@ def __main(args, org: pylo.Organization, pce_cache_was_used: bool, **kwargs):
             for wkl in delete_tracker.workloads:
                 add_workload_to_report(wkl, "TO BE DELETED (aborted by user)")
         else:
-            print(" * Executing deletion requests ... ".format(output_file_csv), end='', flush=True)
+            # execute deletions
+            print(" * Executing deletion requests ... ", end='', flush=True)
             delete_tracker.execute(unpair_agents=True)
             print("DONE")
 
@@ -277,13 +281,29 @@ def __main(args, org: pylo.Organization, pce_cache_was_used: bool, **kwargs):
         for wkl in delete_tracker.workloads:
             add_workload_to_report(wkl, "TO BE DELETED (no confirm option used)")
 
+    # if report is not empty, write it to disk
     if sheet.lines_count() >= 1:
         if len(report_wanted_format) < 1:
             print(" * No report format was specified, no report will be generated")
         else:
             sheet.reorder_lines(['hostname'])  # sort by hostname for better readability
             for report_format in report_wanted_format:
-                output_filename = output_file_prefix + '.' + report_format
+                # Choose output filename depending on whether user provided --output-filename
+                if arg_output_filename is None:
+                    output_filename = output_file_prefix + '.' + report_format
+                else:
+                    # If only one format requested, use the provided filename as-is
+                    if len(report_wanted_format) == 1:
+                        output_filename = arg_output_filename
+                    else:
+                        base = os.path.splitext(arg_output_filename)[0]
+                        output_filename = base + '.' + report_format
+
+                # Ensure parent directory exists
+                output_directory = os.path.dirname(output_filename)
+                if output_directory:
+                    os.makedirs(output_directory, exist_ok=True)
+
                 print(" * Writing report file '{}' ... ".format(output_filename), end='', flush=True)
                 if report_format == 'csv':
                     sheet.write_to_csv(output_filename)

illumio_pylo/utilities/cli.py

@@ -4,7 +4,10 @@ import os
 import sys
 
 # in case user wants to run this utility while having a version of pylo already installed
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))))
+if __name__ == "__main__":
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))))
+    pass
+
 import illumio_pylo.cli
 
 illumio_pylo.cli.run()

illumio_pylo/utilities/health_monitoring.py

@@ -4,7 +4,11 @@ import argparse
 import math
 from datetime import datetime
 
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))))
+# in case user wants to run this utility while having a version of pylo already installed
+if __name__ == "__main__":
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))))
+    pass
+
 import illumio_pylo as pylo
 
 

{illumio_pylo-0.3.11.dist-info → illumio_pylo-0.3.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: illumio_pylo
-Version: 0.3.11
+Version: 0.3.12
 Summary: A set of tools and library for working with Illumio PCE
 Home-page: https://github.com/cpainchaud/pylo
 Author: Christophe Painchaud
@@ -193,6 +193,7 @@ Requires-Dist: paramiko~=3.4.0
 Requires-Dist: prettytable~=3.10.0
 Requires-Dist: requests~=2.32.0
 Requires-Dist: xlsxwriter~=3.2.0
+Requires-Dist: flask~=2.2.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: description