CCNA Discovery Pattern Design Questions

Defining the line delimiter tells the parser where one record ends and the next begins, so each 'key = value' pair is processed as a discrete entry. Without it, the output cannot be split into individual records for attribute extraction.

The connection section handles protocol, credentials, and prompt detection, and command steps run within that established session. Matching the custom prompt ensures the MID Server knows when output ends before sending the next command. This is the designed mechanism for non-standard SSH devices and supports multiple sequential commands with parsing between them.

The MID Server acts as the execution proxy, running pattern commands against targets on behalf of the instance, since Discovery cannot reach those systems directly. It satisfies the requirement for remote command execution during pattern runs.

Pattern Debugger runs a single pattern step-by-step against a target host and displays the parsed variables, letting you confirm the serial number maps correctly to cmdb_ci_lb_device. It validates the identification section without triggering a full Discovery schedule.

Unmapped pattern data is discarded because Discovery only persists extracted values that a pattern maps to a CI attribute or related field. The mapping step defines the target column; without it, the identification and exploration engine has nowhere to write the value, so it is dropped rather than stored in a staging table.

Discovery patterns are reusable, rule-based definitions that query and classify devices, then map discovered attributes into the CMDB as configuration items. They populate the CMDB with CI data, including relationships, rather than merely scanning the network.

Regular expressions are ideal for extracting data from unstructured or semi-structured text where the format may vary. In this case, the 'uname -a' output can differ across distributions, so a regex can be crafted to match the version pattern regardless of surrounding text. It provides flexibility and precision. This is the recommended approach for parsing such command output.

Run as specifies the user privilege under which a pattern step executes, allowing discovery to authenticate with the credentials required to query restricted targets. This satisfies the requirement that configurable step attributes include the execution identity, not merely parsing or probe behaviour.

The Lookup step queries existing CMDB records to return values for pattern population, rather than discovering them from the target device. This satisfies the scenario's requirement to reuse already-stored data, such as resolving a related CI's attributes, instead of performing redundant probes or relying on Microsoft Entra ID or other external sources.

JSON parsing in Pattern Designer deserialises structured device output into key-value pairs, satisfying the stem's requirement for a valid parsing strategy. It handles REST API and modern device responses where nested attributes must be extracted directly, unlike delimiter-based or regex approaches that cannot natively traverse hierarchical JSON structures.

Selecting 'Variable' as the source retrieves the value from a memory variable previously created earlier in the pattern, such as one populated by an earlier step. This allows dynamic values to flow between steps rather than using static text.

Delimited Text parsing is ideal for structured text where fields are separated by a consistent delimiter, such as a tab or comma. In this scenario, each line contains a software name and version separated by a tab, so Delimited Text can split each line into columns and extract the required values efficiently.

Regex parsing extracts the version substring directly by matching the literal "Version:" anchor and capturing the numeric pattern \d+\.\d+\.\d+\.\d+, satisfying the need to isolate 1.2.3.4 from surrounding text in a single pass. Fixed-index or delimiter splitting would require extra steps to strip the label and punctuation.

ServiceNow Discovery patterns support a 'Pattern' step that allows you to call another pattern as a subroutine. By creating a separate pattern with the common steps and invoking it from other patterns, you promote reusability and maintainability. This is the recommended approach for sharing logic across patterns.

The Identification Section in the Pattern Designer defines the criteria used to match and identify a CI, such as serial number or name. It satisfies the requirement to specify identifying attributes, distinguishing it from the Connections or Steps sections, which handle relationships and discovery actions.

The Pattern Log records each pattern's execution steps, including which commands ran and where parsing failed, so reviewing it in Discovery Status reveals the exact point of failure. This satisfies the need to trace pattern behaviour during debugging.

Delimited parsing splits command output on a consistent separator, extracting each field into distinct values for attribute mapping. Because the stem specifies lines separated by a uniform delimiter, this strategy directly matches the data structure and populates the target attributes reliably.

Pattern Designer's Test mode runs a pattern against a chosen Discovery status record's input payload, letting you validate parsing and step logic without launching a full scan. This satisfies the requirement to test in isolation.

Pattern properties include the CI type that the pattern discovers. This setting determines the base CI class for the pattern and is essential for the pattern to correctly create or update CIs in the CMDB. It is configured at the pattern level, not within individual steps.

The Variables tab shows the content of the temporary memory during the current debug session.

Parse Name-Value pair extracts key-value pairs from a multi-line string in one step, splitting on the colon delimiter and returning each key with its value. This directly satisfies the single-step extraction constraint, avoiding manual scripting or repeated string operations.

A regular expression supplies the pattern and capture group that the Parse Variable step uses to isolate the required substring from the larger variable. Without a regex defining the capture group, the step cannot identify which portion of the source string to extract.

The Identification section defines the CI identification rules, so failures there stem from incorrect identifier entries, conditions or table selection. Inspecting it directly reveals why the pattern cannot match incoming data during the identification phase.

Catastrophic backtracking occurs when nested quantifiers force the regex engine to explore exponentially many match paths as input length grows, so a pattern that succeeds on small command outputs can hang indefinitely on large ones. This directly satisfies the stem's focus on extraction challenges, since command outputs are often lengthy and unpredictable.

Name-Value pair parsing splits each line on the delimiter, here the equal sign, mapping the left token to a field name and the right to its value. This directly matches the stated key-value format, unlike regex or XML strategies that assume different structural delimiters.

A step condition allows you to specify a condition that must be true for a particular step to execute. In this scenario, you can add a condition to the Identify step that checks if the hostname starts with 'prod-'. If the condition is false, the step is skipped. This provides granular control over step execution within the pattern.

The Discovery Status record log captures per-step execution output, including the exact error and the step that threw it, so it directly identifies the failing step. This satisfies the stem's requirement to pinpoint causation after a pattern step failure, rather than inferring it from device classification or schedule data.

The Pattern Designer provides a test capability that executes the pattern against a specified device and exposes step-by-step results, including parsed variable values. This lets you confirm the hostname extraction is correct in isolation, without waiting for or affecting a scheduled discovery. It is the intended validation workflow during pattern development.

XPath addresses the nested structure directly by navigating the XML hierarchy with path expressions, selecting a specific child node without manual iteration. This satisfies the stem's requirement to drill down into a particular node within a nested response, unlike flat parsing approaches that cannot target depth precisely.

The Discovery Pattern Log records each pattern step's execution, including the values returned and any attribute-mapping errors. When a CI is identified but an attribute is not written, this log exposes the failing step, unlike horizontal discovery logs that only report overall probe outcomes.

Regex parsing extracts structured attribute values from raw command output, feeding them into the pattern's CI population logic. It satisfies the requirement for a valid output-handling method by transforming unstructured text into discrete fields the identification and exploration steps can consume.

The Call Pattern step invokes another pattern from within the current one, so shared identification logic lives in a single reusable pattern rather than being duplicated. This directly delivers the modularity and reuse the stem requires.

The Pattern Designer Debugger executes a pattern step-by-step on the MID Server, exposing each step's exact input and output values. This satisfies the requirement to inspect the specific failing step's data, which the standard pattern log does not capture.

Pattern Debugger Output captures each step's raw command execution, including stdout and stderr, so you can inspect the exact output produced immediately before the timeout. This satisfies the stem's requirement to investigate the specific preceding command's output, which the Discovery log alone does not expose at step-level granularity.

Regular expressions are case-sensitive by default and may fail if the output has extra spaces or different formatting. This is a common issue when parsing command output. The pattern designer should test the regex against actual output and adjust for case insensitivity or whitespace. This is the most likely cause of the attribute not being populated.

The 'Run as' field on the individual pattern step specifies the OS user account under which that command executes, so setting it to root satisfies the requirement for privileged execution without elevating the whole pattern.

A Set Relation step explicitly defines a relationship between the CI being built and another CI. Referencing the previously captured host identifier ensures the guest is linked to the correct parent. This is the designed construct for expressing containment during pattern execution, so relationships appear in the CMDB after identification and reconciliation.

Dot notation with an array index, `servers[0].id`, traverses the parsed JSON object to the first element of the `servers` array, then reads its `id` property. This satisfies the stem's requirement to reach a nested property inside an array, since Parse JSON exposes the structure as addressable objects and arrays.

Discovery connects to Linux targets over SSH, so it requires SSH credentials — typically a username with either a password or private key. These authenticate the MID Server before patterns run commands such as uname or cat /etc/os-release.

Horizontal discovery begins by identifying the device via probes and sensors, then establishes a connection using the appropriate credentials, and finally extends into the device to collect configuration data. This sequence satisfies the stem's requirement for the correct order of operations, since extension cannot occur before identification and connection succeed.

A Parse Variable step applies a regex to the prior command output, and the capture group isolates the numeric value regardless of surrounding text. This is the standard, robust approach when the value is embedded in a line with a stable label, and it avoids brittle line-position assumptions that break when output formatting changes across OS versions.

Publishing transitions the pattern from Draft to Active, which is the prerequisite state that makes it selectable by Discovery. An unpublished pattern cannot be referenced by a discovery schedule, so publishing must precede any use.

Identification probes create or update the primary CI record itself, whereas Connection probes establish the relationship links between that CI and its dependent CIs. This division satisfies the stem's ownership question: identification owns the CI, connection owns its dependencies.

The 'Define Relationship' step specifies the relationship type and direction between the pattern's CIs, which is mandatory for the pattern to generate the correct CMDB relationship records during discovery. Without it, no relationship type is declared.

Rules determine how the CI is matched.

Parse JSON extracts values from nested JSON structures using path expressions, so an attribute at the third index of a nested array can be targeted precisely. Other step types, such as REST or JDBC, retrieve data but cannot navigate array indices within the returned payload.

The Create Relation step is specifically designed to establish relationships between CIs in the CMDB. In this scenario, you would use it to define the connection between the switch and its connected devices, specifying the relationship type and the two CIs involved. This step ensures the relationship is recorded properly in the CMDB.

Regex is a core parsing strategy in pattern design, matching event fields against defined regular-expression patterns to extract values. It complements other strategies such as delimiters and key-value pairs, and is essential where field content follows predictable textual structures.

The pattern engine blocks on the step process and resumes only when that process returns, so no explicit polling or sleep is needed. This satisfies the requirement that execution pauses until the external script finishes before the next step runs.

Extension sections let common parsing or identification logic be defined once and called from multiple patterns, so changes propagate rather than being duplicated. This satisfies the stem's modularity requirement by promoting reuse of shared logic across patterns.

The Table attribute names the CMDB table that discovery populates, so the Identification step knows which class to query for matching records. It satisfies the stem's requirement by defining the target CMDB class, ensuring identification rules and reconciliation run against the correct table rather than a default or unrelated class.

Conditional logic within a pattern allows branching based on a variable's value, so the pattern can run a fallback command only when the primary result is empty. This keeps a single pattern handling multiple device behaviors without duplicating the entire pattern, and it ensures the CI receives a serial number when any supported command succeeds.

The Pre-sensor script executes custom JavaScript before the payload is processed, allowing manipulation or enrichment of collected data prior to pattern evaluation. This satisfies the requirement to run custom logic ahead of processing, so downstream steps receive adjusted input.

The Search feature queries pattern contents by step name, variable, or activity, letting developers jump directly to a specific element rather than scrolling the canvas. This satisfies the need to locate particular steps or variables quickly within large, complex patterns during debugging or editing.

The Debug panel runs a pattern against a target CI and displays each step's raw output, errors and parsed results. This satisfies the stem's requirement for a key Pattern Designer component by enabling step-level troubleshooting during pattern development and validation.

The Separator attribute specifies the delimiter character, such as a comma or pipe, that marks boundaries between fields in the delimited input. The Parse Delimited step uses it to split each row into individual field values for downstream mapping.

Debug mode runs against a specific Discovery status record, so a node must be selected for the pattern's execution trace to display. Without that selected status record, the debugger has no active discovery context to step through.

The delimiter defines the character marking each field boundary. Specifying the newline escape sequence '\n' makes the parser treat every line break as a row separator, so the input text is split into individual lines, each becoming a distinct row.

Step conditions allow for logic-based execution flow.

Commenting steps documents the logic behind each operation, so other developers can maintain and troubleshoot the pattern without reverse-engineering it. This directly satisfies the maintainability and readability best practice for pattern design, reducing the risk of errors when patterns are revised or reused across discovery schedules.

Set Variable writes a value into a pattern variable that persists across sections, unlike step-local outputs. This satisfies the requirement to store the WMI query result so later sections of the same pattern can reference it.

When the Identification step fails to find a matching CI, the pattern's context variable for the CI's sys_id is empty. Using the condition '${ci.sys_id}' is empty ensures the step runs only when no existing CI was identified, which is exactly what is needed to create a new CI only when none exists.

Pattern Designer renders the execution flow of a pattern graphically, showing each step, the activities performed and their outcomes. This directly satisfies the requirement to visualise how a pattern runs, which the Discovery pattern log or configuration records alone cannot depict.

A for each step iterates over a collection, such as lines of command output, and executes a set of steps for each item. This is perfect for processing multiple entries and creating multiple CIs. It allows dynamic creation of records based on the data. This step type is designed for such repetitive tasks within a pattern.

'Continue on error' overrides the default abort behaviour, so the pattern engine logs the failure and advances to the subsequent step rather than halting the whole execution. This satisfies the stem's question about the outcome of an error in such a step.

This is correct because a Parse step with a regex targeting the 'src' token extracts the exact IP from the command output. The captured group can be mapped to the CI attribute in the pattern's data model, ensuring only the desired value is stored. This approach is robust and handles variations in other parts of the output.

An Extension Section appends custom logic to an existing pattern without altering the base steps, so the original functionality is preserved while your code runs during Discovery. This satisfies the constraint of extending the network switch pattern while keeping its shipped behaviour intact.

Parse JSON extracts named attributes from a JSON payload returned by an API, satisfying the requirement to pull a specific attribute. It converts the response into structured values usable by later pattern steps, unlike simple string or regex operations.