cmdbsyncer 4.2.4__tar.gz → 4.2.6__tar.gz

{cmdbsyncer-4.2.4/cmdbsyncer.egg-info → cmdbsyncer-4.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmdbsyncer
-Version: 4.2.4
+Version: 4.2.6
 Summary: Rule-based modular synchronizer for Checkmk, Netbox, Ansible, I-DOIT, Jira CMDB and 15+ other CMDB/monitoring systems
 Author-email: Kuhn & Ruess GmbH <info@kuhn-ruess.de>
 Maintainer-email: Bastian Kuhn <mail@bastian-kuhn.de>

{cmdbsyncer-4.2.4 → cmdbsyncer-4.2.6}/application/__init__.py

@@ -522,6 +522,12 @@ def _register_web_layer():  # pylint: disable=too-many-locals,too-many-statement
                                        category="Modules",
                                        menu_icon_type='fa', menu_icon_value='fa-cog'))
     #.
+    #   .-- Projects
+    from application.models.project import Project
+    from application.views.project import ProjectView
+    admin.add_view(ProjectView(Project, name="Projects",
+                               menu_icon_type='fa', menu_icon_value='fa-cubes'))
+    #.
 
     _register_all_plugin_admin_views(admin)
 

cmdbsyncer-4.2.6/application/buildinfo.txt

@@ -0,0 +1 @@
+BUILD_DATE=2026-07-16T14:47:35Z

{cmdbsyncer-4.2.4 → cmdbsyncer-4.2.6}/application/changelog/v4.2.md

@@ -1,5 +1,36 @@
 # Version 4.2
 
+## Version 4.2.6
+
+### Projects
+- FEAT: Projects have their own top-level menu entry next to Modules; run `./cmdbsyncer sys self_configure` once after the update so existing projects appear there
+- FEAT: Projects can exclude accounts — the project's members are never exported to the listed accounts, and the exclusion wins over "Exported to Accounts"
+- FEAT: Hosts can be assigned to a Project (host edit form or "Assign Project" bulk action in the host list) — the Checkmk host export then only pushes them to the accounts the project's account filter allows; the assignment never converts an imported host into a CMDB object
+
+### Checkmk
+- FIX: Checkmk Setup/DCD rule exports cache rule results per account, so project rules are no longer served from another account's cached outcomes — previously the first exporting account decided which project rules everyone else got
+- FIX: Opening the host debug page no longer overwrites the cached rule results used by the Checkmk rule export, and its Setup Rules table now shows on every visit instead of only the first
+- FIX: Editing, renaming or deleting a Checkmk Rule Project takes effect on the next export — renames keep the assigned rules attached, and filter changes clear the hosts' cached rule results
+- FIX: Importing a Rule Project from JSON keeps its account filter — imported projects no longer silently export to all accounts
+
+### Interface
+- FIX: The section cards of the modern rule edit forms (e.g. DCD rules: header bars and nested outcome/condition cards) follow the active theme instead of showing hardcoded light backgrounds on the dark themes
+
+### Rules
+- FIX: Editing or deleting a rule now clears the hosts' cached rule results, so exports pick up rule changes immediately instead of using outcomes cached before the edit
+- FIX: `--debug-rules` shows the rule evaluation on every run — an existing rule cache no longer silences the output
+- FEAT: `--debug-rules` shows the deciding condition per rule — which condition failed on a miss, which one matched on a hit
+- FIX: Rule list views no longer crash when a condition was created without negate flags (e.g. programmatically or via JSON import)
+
+## Version 4.2.5
+
+### Setup
+- FEAT: An account can override the global HTTP request timeout with a `request_timeout` custom field (value in seconds) — useful for slow target systems such as large distributed Checkmk setups, where downtime operations can take longer than the default 30 seconds
+
+### Checkmk
+- FIX: Downtime export is much faster on large inventories — it now reads all existing Checkmk downtimes in a single query instead of one per host, so runs that previously appeared to hang for minutes (one livestatus round-trip per matching host) finish quickly
+- FEAT: Downtime export ends with a status line showing how many downtimes were created, how many already existed in Checkmk and how many failed — a run where everything already exists no longer ends silently; the counts are also recorded in the run's log entry
+
 ## Version 4.2.4
 
 ### Checkmk
@@ -14,6 +45,9 @@
 ### Netbox
 - FEAT: Netbox can now import interfaces of devices and virtual machines (analogous to the device and VM import) — each host's Netbox interfaces, including their assigned IP addresses, are stored on the host's inventory; with the account option `import_as_hosts` every interface is instead imported as its own host so it can be exported again
 
+### Jira
+- FEAT: `jira export_cloud --debug` now prints, per object, which fields it changes and their old and new value — so an object that keeps updating on every run (even with `--dry-run`) can be traced to the exact field responsible
+
 ### Interface
 - FIX: Rule forms render fully theme-aware on the dark themes (Gruvbox, Dracula, Nord) — the nested outcome/condition field groups and their "Add …" buttons no longer show a hard-coded white/light background; nested cards, `bg-light`/`bg-white` utilities and the inline "Add" buttons now follow the active theme's surface colours everywhere
 

{cmdbsyncer-4.2.4 → cmdbsyncer-4.2.6}/application/models/host.py

@@ -142,6 +142,12 @@ class Host(db.Document):
 
     folder = db.StringField() # Is just Checkmk related, better solution needed
 
+    # Name of the Project this host belongs to (optional). Exports that
+    # honour projects (currently the Checkmk host export) only push the
+    # host to accounts the project's account filter allows — same scope
+    # as the project's rules.
+    project = db.StringField()
+
     log = db.ListField(field=db.StringField())
 
     cache = db.DictField()

cmdbsyncer-4.2.6/application/models/project.py

@@ -0,0 +1,34 @@
+"""
+Project
+"""
+# pylint: disable=too-few-public-methods
+from application import db
+
+
+class Project(db.Document):
+    """
+    Groups syncer objects (currently Checkmk Setup Rules, DCD rules and
+    hosts — more may follow) and limits which accounts they are exported
+    to. ``limit_by_accounts`` restricts the project's members to the
+    listed accounts; an empty list means no restriction.
+    ``deny_by_accounts`` excludes accounts and wins over the allow list.
+
+    The account-scope decision itself lives with the consumers (see
+    ``application.plugins.checkmk.helpers.project_allows_account``) —
+    this document only carries the data.
+    """
+    name = db.StringField(required=True, unique=True)
+    documentation = db.StringField()
+
+    # Names of the accounts this project's members may be exported to.
+    # Empty = no restriction (all accounts). Stored by name to survive
+    # JSON im-/export between separate syncer instances.
+    limit_by_accounts = db.ListField(field=db.StringField())
+
+    # Names of the accounts this project's members are never exported to.
+    # The deny list wins over ``limit_by_accounts``.
+    deny_by_accounts = db.ListField(field=db.StringField())
+
+    meta = {
+        'strict': False,
+    }

{cmdbsyncer-4.2.4 → cmdbsyncer-4.2.6}/application/modules/plugin.py

@@ -305,9 +305,22 @@ class Plugin():
         logger.debug(f"Request ({method.upper()}) to {url}")
 
         method = method.lower()
+        timeout = app.config['HTTP_REQUEST_TIMEOUT']
+        # Per-account override: a `request_timeout` custom field on the
+        # account wins over the global HTTP_REQUEST_TIMEOUT. Slow target
+        # systems (e.g. large distributed Checkmk setups, where every
+        # downtime read/write fans out to all sites) need more than the
+        # default 30 seconds without raising it deployment-wide.
+        if account_timeout := self.config.get('request_timeout'):
+            try:
+                timeout = float(account_timeout)
+            except (TypeError, ValueError):
+                logger.warning(
+                    f"Ignoring invalid request_timeout {account_timeout!r} "
+                    f"on account {self.config.get('name')!r}")
         payload = {
             'verify': self.verify,
-            'timeout': app.config['HTTP_REQUEST_TIMEOUT'],
+            'timeout': timeout,
         }
 
         if headers:
@@ -524,21 +537,21 @@ class Plugin():
         return self.actions.get_outcomes(db_host, attributes)
 #.
 
-    def debug_rules(self, hostname, model):
+    def debug_rules(self, hostname, _model=None):
         """
         Debug mode for inspecting rule outcomes on a specific host.
-        
+
         This method is used with the --debug-rules command line switch to
-        analyze how rules are applied to a specific host. It clears relevant
-        caches and shows detailed rule processing information.
-        
+        analyze how rules are applied to a specific host. It clears the
+        host's cache and shows detailed rule processing information.
+
         Args:
             hostname (str): Hostname to debug
-            model (str): Model/plugin type for cache key filtering
-            
+            _model (str): Unused, kept for caller compatibility
+
         Returns:
             None: Prints debug information to console
-            
+
         Note:
             This method prints directly to console and is intended for
             interactive debugging sessions.
@@ -551,11 +564,13 @@ class Plugin():
         }
         try:
             db_host = Host.objects.get(hostname=hostname)
-            for key in list(db_host.cache.keys()):
-                if key.lower().startswith(model):
-                    del db_host.cache[key]
-            if "CustomAttributeRule" in db_host.cache:
-                del db_host.cache['CustomAttributeRule']
+            # Clear the host's whole cache. Outcome caches use heterogeneous
+            # keys (e.g. 'ExportDowntimes', qualname-based keys), so the old
+            # model-prefix filter missed them (and compared a lowercased key
+            # against a capitalized prefix). get_outcomes() then returned the
+            # cached result before any debug table was rendered — the debug
+            # run silently printed nothing.
+            db_host.cache = {}
             db_host.save()
         except DoesNotExist:
             print(f"{cc.FAIL}Host not Found{cc.ENDC}")

{cmdbsyncer-4.2.4 → cmdbsyncer-4.2.6}/application/modules/rule/rule.py

@@ -23,6 +23,25 @@ _RULE_DESCRIPTIONS = {
     'anyway': "ALWAYS match",
 }
 
+
+def format_condition(condition):
+    """
+    Compact one-line rendering of a FullCondition dict for debug output,
+    so the deciding condition of a rule match/miss is readable in a table.
+    """
+    if not condition:
+        return ''
+    if condition.get('match_type') == 'tag':
+        tag_negate = ' negated' if condition.get('tag_match_negate') else ''
+        value_negate = ' negated' if condition.get('value_match_negate') else ''
+        return (f"tag {condition.get('tag_match')}{tag_negate} "
+                f"'{condition.get('tag')}', "
+                f"value {condition.get('value_match')}{value_negate} "
+                f"'{condition.get('value', '')}'")
+    hostname_negate = ' negated' if condition.get('hostname_match_negate') else ''
+    return (f"hostname {condition.get('hostname_match')}{hostname_negate} "
+            f"'{condition.get('hostname', '')}'")
+
 class Rule():
     """
     Base Rule Class
@@ -233,12 +252,13 @@ class Rule():
 
             table = Table(title=title, box=box.ASCII_DOUBLE_HEAD,\
                         header_style="bold blue", title_style="yellow", \
-                        title_justify="left", width=90)
+                        title_justify="left", width=130)
             table.add_column("Hit")
             table.add_column("Description")
             table.add_column("Rule Name")
             table.add_column("Rule ID")
             table.add_column("Last Match")
+            table.add_column("Deciding Condition")
 
         outcomes = {}
         rule_objs, prepared_rules = self._iter_rule_docs()
@@ -293,8 +313,20 @@ class Rule():
                     "last_match": str(rule['last_match']),
                 }
                 self.debug_lines.append(debug_data)
+                # Show WHY the rule hit or missed: for 'all' rules the first
+                # failing condition, for 'any' rules the matching one (on a
+                # miss, the last condition checked — all of them failed).
+                if rule_hit:
+                    deciding = format_condition(match_reason)
+                    if deciding:
+                        deciding = f"matched: {deciding}"
+                else:
+                    deciding = format_condition(no_match_reason)
+                    if deciding:
+                        deciding = f"failed: {deciding}"
                 table.add_row(str(rule_hit), _RULE_DESCRIPTIONS[condition_typ],\
-                              rule['name'][:30], str(rule['_id']), str(rule['last_match']))
+                              rule['name'][:30], str(rule['_id']), str(rule['last_match']),
+                              deciding)
             if rule_hit:
                 # outcomes were pre-converted to plain dicts in
                 # _iter_rule_docs so we don't rebuild them per host.
@@ -408,12 +440,20 @@ class Rule():
         return self.check_rules(db_host.hostname)
 
 
-    def get_outcomes(self, db_host, attributes, persist_cache=True):
+    def get_outcomes(self, db_host, attributes, persist_cache=True,
+                     use_cache=True):
         """
         Handle Return of outcomes.
+
+        ``use_cache=False`` bypasses the per-host outcome cache entirely
+        (neither read nor written). Debug evaluations need this: they run
+        with a different rule set than the exports (e.g. all Setup Rules
+        instead of the account's project scope) and must not poison the
+        export's cache slot — nor return a stale cached result instead of
+        producing debug lines.
         """
         cache = self.cache_name or self._default_cache_key
-        if cache in db_host.cache:
+        if use_cache and cache in db_host.cache:
             logger.debug("Using Rule Cache for %s", db_host.hostname)
             return db_host.cache[cache]
 
@@ -421,9 +461,10 @@ class Rule():
         self.hostname = db_host.hostname
         self.db_host = db_host
         rules = self.check_rule_match(db_host)
-        db_host.cache[cache] = rules
-        if persist_cache:
-            db_host.save()
-        else:
-            setattr(db_host, '_cache_dirty', True)
+        if use_cache:
+            db_host.cache[cache] = rules
+            if persist_cache:
+                db_host.save()
+            else:
+                setattr(db_host, '_cache_dirty', True)
         return rules

{cmdbsyncer-4.2.4 → cmdbsyncer-4.2.6}/application/modules/rule/views.py

@@ -18,6 +18,7 @@ from application.views.default import DefaultModelView
 from application.modules.rule.models import filter_actions, rule_types, condition_types
 from application.docu_links import docu_links
 from application.helpers.sates import add_changes
+from application.models.host import Host
 from flask_admin.contrib.mongoengine.filters import BooleanEqualFilter, FilterLike
 
 
@@ -258,10 +259,28 @@ def _render_attribute_outcomes(_view, _context, model, _name):
     return Markup(html)
 
 
+def invalidate_host_rule_caches():
+    """
+    Drop the per-host rule outcome caches after a rule was changed.
+
+    ``db_host.cache`` is only reset when the host's own labels or inventory
+    change — a rule edit alone never touches it. Exports would keep using
+    the outcomes cached before the edit until every host happens to be
+    re-imported (reported from the field: a corrected downtime rule
+    exported nothing for most hosts). Outcome cache keys are heterogeneous
+    (e.g. 'ExportDowntimes', qualname-based keys), so a prefix-scoped clear
+    is not possible — drop the whole cache, the next run recomputes it.
+    """
+    Host.objects(cache__ne={}).update(set__cache={})
+
+
 def _render_full_conditions(_view, _context, model, _name):
     """
     Render full condition set which contains host or labels
     """
+    # Rules created programmatically or via JSON import may carry None in
+    # the negate booleans or match-type fields — render them like their
+    # defaults instead of raising a KeyError that breaks the whole list view.
     negate = {
         True: 'not ',
         False: ' ',
@@ -275,9 +294,9 @@ def _render_full_conditions(_view, _context, model, _name):
                     <h6 class="card-subtitle mb-2 text-muted">Hostname</h6>
                     <p class="card-text">
                      <span class="badge badge-primary">
-                     {escape(negate[entry.hostname_match_negate])}
-                     {escape(condition_types[entry.hostname_match])}</span>
-                    <span class="badge badge-info">{escape(entry.hostname)}</span>
+                     {escape(negate[bool(entry.hostname_match_negate)])}
+                     {escape(condition_types.get(entry.hostname_match, ''))}</span>
+                    <span class="badge badge-info">{escape(entry.hostname or '')}</span>
                     </p>
                   </div>
                 </div>
@@ -289,16 +308,18 @@ def _render_full_conditions(_view, _context, model, _name):
                     <h6 class="card-subtitle mb-2 text-muted">Key</h6>
                     <p class="card-text">
                      <span class="badge badge-primary">
-                        {escape(negate[entry.tag_match_negate])}{escape(condition_types[entry.tag_match])}
+                        {escape(negate[bool(entry.tag_match_negate)])}{escape(
+                            condition_types.get(entry.tag_match, ''))}
                      </span>
-                     <span class="badge badge-info">{escape(entry.tag)}</span>
+                     <span class="badge badge-info">{escape(entry.tag or '')}</span>
                     </p>
                     <h6 class="card-subtitle mb-2 text-muted">Value</h6>
                     <p class="card-text">
                     <span class="badge badge-primary">
-                        {escape(negate[entry.value_match_negate])} {escape(condition_types[entry.value_match])}
+                        {escape(negate[bool(entry.value_match_negate)])} {escape(
+                            condition_types.get(entry.value_match, ''))}
                     </span>
-                    <span class="badge badge-info">{escape(entry.value)}</span>
+                    <span class="badge badge-info">{escape(entry.value or '')}</span>
                     </p>
                   </div>
                 </div>
@@ -448,6 +469,7 @@ class RuleModelView(DefaultModelView):
         Overwrite Actions on Model Change
         """
         add_changes()
+        invalidate_host_rule_caches()
 
         try:
             super().on_model_change(form, model, is_created)
@@ -460,6 +482,7 @@ class RuleModelView(DefaultModelView):
         Overwrite Actions on Model Delete
         """
         add_changes()
+        invalidate_host_rule_caches()
 
         return super().on_model_delete(model)
 
@@ -586,6 +609,7 @@ class FiltereModelView(DefaultModelView):
         Overwrite Actions on Model Change
         """
         add_changes()
+        invalidate_host_rule_caches()
 
         try:
             super().on_model_change(form, model, is_created)
@@ -598,6 +622,7 @@ class FiltereModelView(DefaultModelView):
         Overwrite Actions on Model Delete
         """
         add_changes()
+        invalidate_host_rule_caches()
 
         return super().on_model_delete(model)
 

{cmdbsyncer-4.2.4 → cmdbsyncer-4.2.6}/application/plugins/checkmk/__init__.py

@@ -209,11 +209,11 @@ def get_host_debug_data(hostname):
 
     try:
         db_host = Host.objects.get(hostname=hostname)
-        for key in list(db_host.cache.keys()):
-            if key.lower().startswith('checkmk'):
-                del db_host.cache[key]
-        if 'CustomAttributeRule' in db_host.cache:
-            del db_host.cache['CustomAttributeRule']
+        # Clear the host's whole cache: outcome caches use heterogeneous
+        # keys (e.g. 'ExportDowntimes', 'cmk_tags_tag_choices', qualname
+        # based keys), so the old 'checkmk' prefix filter missed them and
+        # the debug run showed stale cached results for those engines.
+        db_host.cache = {}
         db_host.save()
     except DoesNotExist:
         print(f"{ColorCodes.FAIL}Host not Found{ColorCodes.ENDC}")
@@ -248,7 +248,11 @@ def get_host_debug_data(hostname):
             setup_rules = CheckmkRulesetRule()
             setup_rules.debug = True
             setup_rules.rules = CheckmkRuleMngmt.objects(enabled=True).order_by('sort_field')
-            setup_rules.get_outcomes(db_host, attributes['all'])
+            # use_cache=False: the debug run evaluates all Setup Rules
+            # instead of the account's project scope and must neither
+            # poison the export's cache slot nor short-circuit on a
+            # cached result (which would leave the debug table empty).
+            setup_rules.get_outcomes(db_host, attributes['all'], use_cache=False)
             rule_logs['Setup Rules'] = setup_rules.debug_lines
         except Exception as exp:  # pylint: disable=broad-exception-caught
             rule_logs['Setup Rules'] = [{
@@ -432,13 +436,13 @@ def cli_export_rules(account, debug):
 @click.option("--debug", is_flag=True)
 def cli_import_project_rules(project, account, folder, recursive, debug):
     """
-    Import all Checkmk Setup Rules of a folder into a Rule Project
+    Import all Checkmk Setup Rules of a folder into a Project
 
     ### Example
     _./cmdbsyncer checkmk import_project_rules MYPROJECT SITEACCOUNT /server_
 
     Args:
-        project (string): Name of the target Checkmk Rule Project
+        project (string): Name of the target Project
         account (string): Checkmk account to read the rules from
         folder (string): Checkmk folder to import rules from
     """

{cmdbsyncer-4.2.4 → cmdbsyncer-4.2.6}/application/plugins/checkmk/admin_views.py

@@ -21,7 +21,6 @@ from .models import (
     CheckmkRewriteAttributeRule,
     CheckmkRule,
     CheckmkRuleMngmt,
-    CheckmkRuleProject,
     CheckmkSettings,
     CheckmkSite,
     CheckmkTagMngmt,
@@ -37,7 +36,6 @@ from .views import (
     CheckmkFolderPoolView,
     CheckmkInventorizeAttributesView,
     CheckmkMngmtRuleView,
-    CheckmkRuleProjectView,
     CheckmkNotificationRuleView,
     CheckmkPasswordView,
     CheckmkRuleView,
@@ -108,15 +106,6 @@ def register_admin_views(admin):
             menu_icon_value='fa-cogs',
         )
     )
-    admin.add_view(
-        CheckmkRuleProjectView(
-            CheckmkRuleProject,
-            name="Setup Rule Projects",
-            category="Checkmk",
-            menu_icon_type='fa',
-            menu_icon_value='fa-cubes',
-        )
-    )
     admin.add_view(
         CheckmkTagMngmtView(
             CheckmkTagMngmt,

{cmdbsyncer-4.2.4 → cmdbsyncer-4.2.6}/application/plugins/checkmk/cmk_rules.py

@@ -627,10 +627,10 @@ class CheckmkRuleSync(CMK2):
         # Host-independent rules, wired in by inits.export_rules. Evaluated
         # once in calculate_static_rules instead of per host.
         self.static_rules = []
-        # Name of the CheckmkRuleProject this run belongs to (set by
-        # inits.export_project_rules). Scopes the ``rule_marker`` so a
-        # project push only ever manages/cleans its own rules — two projects
-        # can share the same Checkmk instance without clobbering each other.
+        # Optional Project name scoping the ``rule_marker``.
+        # The current export runs are account-wide (all allowed projects in
+        # one pass), so this stays None there — it is kept for callers that
+        # manage a single project's rules in isolation.
         self.project = None
 
     @property

{cmdbsyncer-4.2.4 → cmdbsyncer-4.2.6}/application/plugins/checkmk/downtimes.py

@@ -18,6 +18,13 @@ class CheckmkDowntimeSync(CMK2):
     # Reset Log Details
     #log_details = []
 
+    def __init__(self, account=False):
+        super().__init__(account)
+        # Run statistics for the final status line: without it a run where
+        # every configured downtime already exists in Checkmk ends silently
+        # and looks broken to the operator.
+        self.dt_stats = {'created': 0, 'existing': 0, 'failed': 0}
+
 
     def ahead_days(self, offset):
         """
@@ -216,16 +223,20 @@ class CheckmkDowntimeSync(CMK2):
             data['duration'] = int(downtime['duration'])
         try:
             self.request(url, method="POST", data=data)
+            self.dt_stats['created'] += 1
             print(f"\n{cc.OKGREEN} *{cc.ENDC} Set Downtime for "\
                   f"{data['start_time']} ({data['comment']})")
         except CmkException as error:
+            self.dt_stats['failed'] += 1
             self.log_details.append(("error", f"Downtime failed {error}"))
             print(f"\n{cc.WARNING} *{cc.ENDC} Downtime failed: "\
                   f"{error}")
 
-    def do_hosts_downtimes(self, hostname, host_actions, attributes):
+    def do_hosts_downtimes(self, hostname, host_actions, attributes, current_downtimes):
         """
-        Calls for one Hosts Downtime
+        Set the configured downtimes for one host that are not already
+        present in Checkmk. ``current_downtimes`` is this host's slice of the
+        downtimes ``run()`` read once up front in a single bulk query.
         """
         try:
             configured_downtimes = []
@@ -234,12 +245,11 @@ class CheckmkDowntimeSync(CMK2):
                     configured_downtimes += \
                             list(self.calculate_configured_downtimes(rule, attributes['all']))
 
-            current_downtimes = list(
-                        self.get_current_cmk_downtimes(hostname)
-                    )
             for downtime in configured_downtimes:
                 if downtime not in current_downtimes:
                     self.set_downtime(hostname, downtime)
+                else:
+                    self.dt_stats['existing'] += 1
         except Exception as exp:  # pylint: disable=broad-exception-caught
             self.log_details.append(('error', f'Exception {exp}'))
             print(f"Exception: {exp}")
@@ -248,6 +258,13 @@ class CheckmkDowntimeSync(CMK2):
         """
         Export Downtimes
         """
+        # Read every current host downtime in a single bulk query up front
+        # instead of one query per host inside the loop. On large inventories
+        # that turns hundreds of serial livestatus round-trips (one per host
+        # matching a downtime rule) into a single call — the previous
+        # per-host reads were what made the export appear to hang.
+        current_by_host = self.get_all_cmk_downtimes()
+
         # Collect Rules
         total = Host.active_non_template().count()
         with Progress(SpinnerColumn(),
@@ -270,9 +287,18 @@ class CheckmkDowntimeSync(CMK2):
                 if not host_actions:
                     progress.advance(task1)
                     continue
-                self.do_hosts_downtimes(hostname, host_actions, attributes)
+                self.do_hosts_downtimes(hostname, host_actions, attributes,
+                                        current_by_host.get(hostname, []))
                 progress.advance(task1)
 
+        # Final status line: a fully deduplicated run creates nothing and
+        # would otherwise end without any output, which reads like a failure.
+        print(f"{cc.OKGREEN} -- {cc.ENDC}Downtimes: {self.dt_stats['created']} created, "
+              f"{self.dt_stats['existing']} already present in Checkmk, "
+              f"{self.dt_stats['failed']} failed")
+        for key, value in self.dt_stats.items():
+            self.log_details.append((f'downtimes_{key}', value))
+
     def run_async(self):
         """
         Export Downtimes
@@ -308,25 +334,32 @@ class CheckmkDowntimeSync(CMK2):
         #        pool.close()
         #        pool.join()
 
-    def get_current_cmk_downtimes(self, hostname):
-        """
-        Read Downtimes from Checkmk
+    def get_all_cmk_downtimes(self):
         """
+        Read all host downtimes from Checkmk in one query, grouped by
+        hostname (``{hostname: [downtime, ...]}``).
 
-        url = f"domain-types/downtime/collections/all?"\
-              f"host_name={hostname}&downtime_type=host"
+        Used by ``run()`` so the whole export does a single downtime read
+        instead of one per host — the per-host reads were the reason the
+        export appeared to hang on large inventories.
+        """
+        url = "domain-types/downtime/collections/all?downtime_type=host"
         response = self.request(url, method="GET")
         # request() returns an empty ``{}`` body on error responses
         # (404, non-200, no content). Guard the lookup so a failed
         # downtime read yields "no current downtimes" instead of a bare
         # KeyError that would escape as a detail-less run failure.
         downtimes = response[0].get('value', []) if response[0] else []
+        by_host = {}
         for downtime in downtimes:
-            yield {
-                "start" : datetime.datetime.fromisoformat(
-                        downtime["extensions"]["start_time"]),
-                "end" : datetime.datetime.fromisoformat(
-                        downtime["extensions"]["end_time"]),
-                "comment" : downtime["extensions"]["comment"],
-                "duration" : downtime["extensions"].get("duration", False),
-            }
+            extensions = downtime.get('extensions', {})
+            hostname = extensions.get('host_name')
+            if not hostname:
+                continue
+            by_host.setdefault(hostname, []).append({
+                "start": datetime.datetime.fromisoformat(extensions["start_time"]),
+                "end": datetime.datetime.fromisoformat(extensions["end_time"]),
+                "comment": extensions["comment"],
+                "duration": extensions.get("duration", False),
+            })
+        return by_host

{cmdbsyncer-4.2.4 → cmdbsyncer-4.2.6}/application/plugins/checkmk/helpers.py

@@ -32,3 +32,23 @@ def cmk_cleanup_hostname(input_str):
         for needle, replacer in app.config['REPLACERS']:
             input_str = input_str.replace(needle, replacer)
     return re.sub('[^a-zA-Z0-9_-]', '_', input_str.strip()).lower()
+
+
+def project_allows_account(project, account_name):
+    """
+    True when a Project's rules (and assigned hosts) may be
+    exported to ``account_name``: not on the project's ``deny_by_accounts``
+    list, and either no ``limit_by_accounts`` allow list is set or the
+    account is on it. The deny list wins over the allow list.
+
+    Lives here (not on the model) so the account-scope decision is shared
+    by the rule exports, the host export and the model without importing
+    MongoEngine documents.
+    """
+    denied = [name for name in (getattr(project, 'deny_by_accounts', None) or [])
+              if name]
+    if account_name in denied:
+        return False
+    allowed = [name for name in (getattr(project, 'limit_by_accounts', None) or [])
+               if name]
+    return not allowed or account_name in allowed