ScrapliGo

The read_with_callbacks method allows you to handle device interactions, tail logs, or manage long-running outputs by triggering specific function calls based on the content received. This is particularly useful for:

• Connecting to device consoles during boot-up.
• Zero-touch-provisioning (ZTP) workflows.
• Tailing logs or other continuous streams where specific patterns should trigger actions.

Instead of a standard read that waits for a specific prompt or EOF, read_with_callbacks enables an event-driven approach to reading device output.

// Note: The actual implementation is found in the example code file, 
// but the concept involves passing callback functions to the read_with_callbacks method.

You can use textfsm (and optionally ntc-templates) to convert unstructured text output from a network device into a structured object.

Important Note for Go Users: Unlike the Python version (scrappy), scrapligo does not perform automatic template lookups with ntc-templates. You must explicitly provide the template path or URL when performing the parse operation.

When running the provided examples, you can override the default connection parameters using environment variables. This is useful if you are targeting a different device or a different network configuration.

You can override the following parameters:

• Platform (e.g., srlinux)
• Host
• Port
• Username
• Password

Note: Changing the target platform type may cause examples to fail if the underlying logic is specific to the default platform.

Because Netconf subscription implementations vary significantly depending on the RFC supported by the server, scrapligo does not provide a high-level abstraction for subscriptions. Instead, you should implement subscriptions manually using the raw_rpc method.

Depending on the device/server type, you will use different methods to retrieve notifications:

1. For RFC-compliant servers (e.g., Netopeer) using create-subscription: Use the get_next_notification method to fetch notification messages.
2. For devices (e.g., Cisco IOS-XE) using establish-subscription: Use the get_next_subscription method, as these subscriptions are associated with a specific subscription ID.

The Cli object provides three primary methods for sending data (inputs) to a device. Use these methods depending on whether you are sending a single input, multiple inputs, or inputs loaded from a file:

• SendInput: Sends a single input string to the device.
• SendInputs: Sends a slice of input strings to the device.
• SendInputsFromFile: Reads inputs from a specified file and sends them to the device.

For simple semi-interactive device prompts—such as confirming a configuration write or a file deletion—use the basic interaction handling capabilities provided by ScrapliGo. This approach is intended for straightforward prompts where the user or automation needs to respond to a specific device request.

For more complex or elaborate interactive scenarios (e.g., multi-step dialogues or conditional logic based on prompt content), use the read_with_callbacks method instead.

Scrapli uses "platform definitions" to determine how to interact with specific device types, including the expected prompt shape and available device modes. While many definitions are bundled with Scrapli, you can provide your own custom definition by pointing Scrapli to a YAML file. This is useful for unsupported platforms, new releases not yet packaged, or custom device configurations.

To implement a custom definition, you must follow the platform definition schema. The schema is defined by the core libscrapli types or the Pydantic schema used in the scrapli_definitions test suite.

Scrapli (Go) provides flexibility in how logs are handled. You can use any of the following three methods to configure logging:

1. Standard log.Logger: Use the standard library's logging implementation.
2. Structured log/slog.Logger: Use the modern structured logging library introduced in Go.
3. Custom Callback: Provide your own callback function to handle log messages according to your specific requirements.

The choice of logger depends on your application's needs for simplicity, structured data, or custom routing.